MSVS2005 Standard: insertion operator overload: LNK2028

[phiefer3]

I'm currently a student, but this problem isn't directly related to what I have to do on an assignment. It's just a problem I've had with some supporting features.

First of all, I'm using MSVS 2005 standard edition. I haven't downloaded or acquired any additional libraries or tools, just what gets installed with the studio by default. Also, I'm using C++ and started the problem projects as an empty CLR project.

Currently I've had several data structure assignments that required me to make class templates for linked lists, stacks, queues, etc. As a feature of these structures, I like to overload the insertion operator (<<) so that it's simpler to output the entire structure. I've followed everything mentioned from my text books, and even resorted to copying an entire example word for word, and the problem still persists.

And all of my files include the iostream header file and the usingnamespace std; statement. And the function definition is in the same header file as the class definition.

In the class template definition, my prototype for overloading the operator looks like this:

friend ostream& operator<<(ostream&, const linkedQueue<Type>&);

The definition of the overload is as follows:

template<class Type>
ostream& operator<<(ostream& outPut, const linkedQueue<Type>& thisQueue)
{
    //makes a pointer to the first element in the queue
    queueNode<Type> *current;
    current = thisQueue.first;
 
    //steps through the elements of the queue without
    //changing anything.
    while (current != NULL)
    {
        //outputs the data stored in the current node
        outPut << current->data << endl;
 
        //moves current to the next node
        current = current->next;
    }
 
    return outPut;
 
}//end insertion overload

When I include in my function main() the line ("object" is an object of the class template the function was overloaded for):

cout << object;

I get 3 errors:

main.obj : error LNK2028: unresolved token (0A00029B)
main.obj : error LNK2019: unresolved external symbol
(project path and name).exe : fatal error LNK1120: 2 unresolved externals

I'd just like to know how to get the insertion operator to work with class templates.

I appreciate any help I receive.

[weaknessforcats]

What does your main() look like and how are you creating the object?

[phiefer3]

What does your main() look like and how are you creating the object?

Well for the sake space, I won't post the entire main(), but the following is an example, that has the same results.

#include <iostream>
 
//header file containing the template mentioned earlier
#include “linkedQueue.h”
 
using namespace std;
 
int main()
{
    linkedQueue<int> myQueue;
 
    //add items to the queue…
    for (int i = 0; i < 10; i++)
        myQueue.addElement(i);
 
    cout << myQueue;
 
    return 0;
}

also, the addElement function works fine, that's not the problem. I can replace the overloaded insertion operator with a function that takes an ostream as a parameter to output the contents, and it works fine, it's just when I try to use the overloaded operator<<

also, if I make my queue class into a regular class instead of a template, it works fine.

[weaknessforcats]

This code:

linkedQueue<int > myQueue;
....

needs an operator<< like this:

ostream& operator<<(ostream&, const linkedQueue<int>);
 

The int has been used in the friend declaration of the LinkeQueue class.

but you have this template outside the class:

template<class Type>
ostream& operator<<(ostr eam& outPut, const linkedQueue<Typ e>& thisQueue)
......

So when you code:

cout << myQueue;
 

your operator<< template specializes as:

ostream& operator<<(ostream& outPut, const linkedQueue<linkedQueue<int> >& thisQueue)
 

because Type is now LinkedQueue<int > and not just int.
and this is not the operator<< you need so

ostream& operator<<(ostream&, const linkedQueue<int>);
 

is missing and that's what the linker is reporting.

All of this is happening because your friend operator<< is bound to the class template. When you specialize the class template with an int you also specialize the friend with an int.

You can have a friend be unbound to the class by declaring the friend to be template in the class template itself:

class LinkedQueue
{
 
public:
    template<class Type>    //unbound friend
    friend ostream& operator<<(ostream& os, const LinkedQueue<Type>& q);
};
 

When you do this, the friend function becomes a friend to every class specialization.

Now you have your

ostream& operator<<(ostream&, const linkedQueue<int>);
 

and off you go.

[phiefer3]

So in other words, the operator<< template is using the right hand argument as the Type parameter?

Or, I still don't quite grasp the logic behind it. Anyways, it works now, and that's good enough for now.

Thanks for the help.

[weaknessforcats]

When you create LinkedQueue<int >, you also create a template function:

ostream& operator<<(ostream& os, const LinkedQueue<int>& q);
 

that is a friend to LinkedQueue<int >.

Later you do:

cout << myQueue;
 

which needs

ostream& operator<<(ostream& os, const LinkedQueue<int>& );
 

you have already created that template function, so off you go.

If you don't do this, then

cout << myQueue;
 

creates

ostream& operator<<(ostream& os, const LinkedQueue<LinkedQueue<int> >& );
 

from the operator<< template and that's not the function you need.