C++: Overloading the << operator

Question

I have a very silly problem that I just can't figure out. I'm trying to overload the << operator in my "PrioQueue" class. I'm still pretty new to C++ and i've tried almost every example I could find on the web but nothing works.

The PrioQueue is a template class I made that works like a normal Queue but puts the highest value it receives on the top.

PrioQueue<int> intq1(5);
intq1.push(1);
intq1.push(2);
intq1.push(1);
cout << intq1;

The << operator should write all the values that I've pushed to the queue with a '|' in between. So like this:

2 | 1 | 1 |

This is my overload operator << method.

friend std::ostream& operator<<(std::ostream& out, PrioQueue q){
    while(!q.empty()){
        out.write(q.pop()); //This method pops off the top value and returns it
    }
    return out;

}

I hope this is enough information but if not. This is my full code:

#include "stdafx.h"
#include <iostream>
#include <ostream>
using namespace std;

template <typename Type>
class PrioQueue
{
private:
Type *bottom_;
Type *top_;
int size_;
public:
PrioQueue(Type size){
    bottom_ = new Type[size];
    top_ = bottom_;
    size_ = size;
}

friend PrioQueue operator+(PrioQueue q1, PrioQueue q2){
    while(!q2.empty()){
        q1.push(q2.pop());
    }
    return q1;
}

friend std::ostream& operator<<(std::ostream& out, PrioQueue q){
    while(!q.empty()){
        out.write(q.pop());
    }
    return out;
}


//Checks to see if the given value is bigger than the bottom character. 
//If so, the bottom and the given value swap places. 
//If not, the value gets placed at the top of the queue
void push(Type t){
    if(*bottom_ < t){
        *top_ = *bottom_;
        *bottom_ = t;
    }else{
        *top_ = t;
    }
    top_++;
}

int num_items() {
    return (top_ - bottom_);
}

Type pop(){
    return *(bottom_++);
}

int full() {
    return (num_items() >= size_);
}

int empty() {
    return (num_items() <= 0);
}

void print(){
    cout << "Queue currently holds " << num_items() << " items: " ;
    for (Type *element=top_-1; element >= bottom_; element--) {
        cout << " " << *element;
    }
    cout << "\n";
}

int getSize(){
    return size_;
}

~PrioQueue(){ // stacks when exiting functions
    bottom_ = 0;
    delete[] bottom_;
}
};

void intExample(){
PrioQueue<int> intq1(5);
intq1.push(1);
intq1.push(2);
intq1.push(1);
cout << intq1;

intq1.print();

PrioQueue<int> intq2(5);
intq2.push(8);
intq2.push(2);
intq2.push(5);
intq2.print();

PrioQueue<int> intq3(10);
intq3 = intq1 + intq2;
intq3.print();

cout << intq3;
}

void charExample(){
PrioQueue<char> charq1(5);
charq1.push('t');
charq1.push('h');
charq1.push('g');
charq1.print();

PrioQueue<char> charq2(5);
charq2.push('i');
charq2.push('q');
charq2.push('k');
charq2.print();

PrioQueue<char> charq3(10);
charq3 = charq1 + charq2;
charq3.print();
}

int main(){
intExample();
charExample();

return 0;
}

Answer 1

This would work:

friend std::ostream& operator<<(std::ostream& out, PrioQueue q){
  while(!q.empty()){
    out << q.pop() << "|";
  }
  return out << "\n"; // if you want a newline, otherwise just "return out;"
}

Edit Note that for this to work, you will have to modify your queue to be copyable. You need to add a copy constructor and an assignment operator (see the rule of three) or use a type that is copyable and assignable to store your data (see std::vector, std::deque, or container adapter std::priority_queue if this is not an exercise).

Answer 2

The problem is that the out.write() expects a const char* and size. First of all, your Type will not implicitly convert to const char* and also, you're missing an argument.

Using out << q.pop() will fix the problem for you.