Why am I getting error:Undefined reference to operator<<

[Bopaki]

That operator<< is declared and defined in the program.

#include<iostream>
#include<cassert>
using namespace std;

template<class Type>
struct nodeType
{
    Type info;
    nodeType<Type> *link;
};
template<class Type>
class linkedListType
{
  friend ostream& operator<<(ostream&, const linkedListType<Type>&);

public:
   const linkedListType<Type>& operator=( const linkedListType<Type>&);
void initializeList();
bool isEmptyList();
int length();
 void destroyList();
 Type front();
 Type back();
bool search(const Type& searchItem);
void insertFirst(const Type& newItem );
void insertLast(const Type& newItem);
void insertNode(const Type& newItem)  ; 
    void insert(const Type& newItem) ;
void deleteNode(const Type& deleteItem);
linkedListType();
linkedListType(const linkedListType<Type>& otherList);
~linkedListType();

//protected:
   int count;
nodeType<Type> *first;
nodeType<Type> *last;

private:
    void copyList(const linkedListType<Type>& otherList);
};
template<class Type>
bool linkedListType<Type>::isEmptyList()
{
    return(first == NULL);
}
template<class Type>
linkedListType<Type>::linkedListType()
{
    first = NULL;
    last = NULL;
    count = 0;
}
template<class Type>
void linkedListType<Type>::destroyList()
{
    nodeType<Type> *temp;
    while(first != NULL)
    {
        temp = first;
        first = first-> link;
        delete temp;
    }
    last = NULL;
    count = 0;
}
template<class Type>
void linkedListType<Type>::initializeList()
{
    destroyList();
    }
template<class Type >
ostream& operator<<(ostream& osObject, const linkedListType<Type>& list)
{
   nodeType<Type> *current;
   current = list.first;
    while(current != NULL)
   {
        osObject<<current->info<<" ";
      current = current->link;
   }
    return osObject;
}
template<class Type >
int linkedListType<Type>::length()
{
    return count;
}
template<class Type >
Type linkedListType<Type>::front()
{
    assert(last != NULL);
    return first->info;
}
template<class Type>
Type linkedListType<Type>::back()
{
    assert(last != NULL);
    return last->info;
}
template<class Type>
bool linkedListType<Type>::search(const Type& searchItem)
{
    nodeType<Type> *current;
    bool found;
    current = first;
    found = false;
    while(current != NULL && !found)
        if(current->info == searchItem)
          found = true;
        else
           current = current->link;
    return found;
}
template<class Type>
void linkedListType<Type>::insertFirst(const Type& newItem)
{
    nodeType<Type> *newNode;
    newNode = new nodeType<Type>;
    assert(newNode != NULL);
   newItem->info = newItem;
    newNode->link = first;
    first = newNode;
    count++;
    if(last == NULL) ;
    last = newNode;
}
template<class Type>
void linkedListType<Type>::insertLast(const Type& newItem)
{
    nodeType<Type> *newNode;
    newNode = new nodeType<Type>;
    assert(newNode != NULL);
    newNode->info = newItem;
    newNode->link = NULL;
    if(first == NULL)
    {
        first = newNode;
        last = newNode; 
        count++;
    }
    else
    last->link = newNode;
    last = newNode;
    count++;
}
template<class Type>
void linkedListType<Type>::insertNode(const Type& newItem)
{
    nodeType<Type> *current;
    nodeType<Type> *trailCurrent;
    nodeType<Type> *newNode;
    bool found;
    newNode = new nodeType<Type>;
    assert(newNode != NULL);
    if(first == NULL)
    {
        first = newNode;
        count++;

}
    else
    {
    current = first;
    found = false;
        while(current != NULL && !found)
        if(current->info >= newItem)
        found = true;
        else{
            trailCurrent = current;
        current = current->link;
            
        }
        if(current == first)
        {
        newNode->link = first;
            first = newNode;
            count++;
    }
        else
{
        trailCurrent->link = newNode;
            newNode->link = current;
            count++;
    }
}
}
template<class Type>
void linkedListType<Type>::insert(const Type& newItem)
{
   nodeType<Type> *newNode;
    newNode = new nodeType<Type>;
   assert(newNode != NULL);
    newNode->info = newItem;
    newNode->link = NULL;
 if(first == NULL) 
    {
       first = newNode;
        last = newNode;  
    count++;
        }
    else
    {
        last->link = newNode;
        last = newNode;
        count++;
}

}
template<class Type>
void linkedListType<Type>::deleteNode
(const Type& deleteItem)
{
    nodeType<Type> *current;
    nodeType<Type> *trailCurrent;
    bool found;
    
    if(first == NULL)
        cerr<<"Cannot delete from an empty list.\n";
    else
    {
        if(first->info == deleteItem)
        {
            current = first;
            first = first->link;
            count--;
            if(first == NULL)
                last = NULL;
            delete current;
        }
        else
        {
        found = false;
        trailCurrent = first;
            current = first->link;
            
            while(current != NULL && !found)
            {
                if(current->info != deleteItem)
                {
                    trailCurrent = current;
                    current = current->link;
                }
                else
                    found = true;
            }
            if(found)
            {
            trailCurrent->link = current->link;
                count--;
                if(last == current)
                last = trailCurrent;
                delete current;
        }
        else
            cout<<"Item to be deleted is not in  the list."<<endl;

         }
    }
}
    
template<class Type>
void linkedListType<Type>::copyList (const linkedListType<Type>& otherList)
{
    nodeType<Type> *newNode;
    nodeType<Type> *current;
    if(first != NULL)
        destroyList();
    if(otherList.first == NULL)
    {
        first = NULL;
        last == NULL;
        count = 0;
    }
    else
    {
        current = otherList.first;
        count = otherList.count;
        //Copy the first node
      first = new nodeType<Type>;
      assert(first != NULL);
      first->info = current->info;
      first->link = NULL;
        last = first;
        current = current->link;
        //Copy the remaining list
    while(current != NULL)
    { 
        newNode = new nodeType<Type>;
        assert(newNode != NULL);
        newNode->info = current->info;
        newNode->link = NULL;
            
        last->link = newNode;
        last = newNode;
            
        current = current->link;
            }
    }                 
 }
template<class Type>
linkedListType<Type>::~linkedListType()
{
    destroyList();
    }
template<class Type>
linkedListType<Type>::linkedListType (const linkedListType<Type>& otherList)
{
    first = NULL;
    copyList(otherList);
    }
template<class Type>
const linkedListType<Type>& linkedListType<Type>::operator=(const linkedListType<Type>& otherList)
{
    if(this != &otherList)
       copyList(otherList);
    
     return *this;
}
int main()
{
  linkedListType<int> list1, list2;
   int num;
    cout<<"Enter numbers ending with -999.\n";
    cin >> num;
  while(num != -999)
   {
     list1.insert(num);
       cin>>num;
   }
   cout<<endl;
   cout<<"List1: " <<list1 <<endl;
   list2 = list1;
   cout<<"List2: "<< list2 << endl;
   cout<<"Enter the number to be )/deleted"<<endl;
   cin >> num;
 cout  <<endl; 
    list2.deleteNode(num);
    cout<<"After deleting node: " <<"List2 : " <<endl <<list2 <<endl;
   return 0;
    

[Bopaki]

Declared at line 14.
Defined at line 72 - 83

[keskiverto]

Is the error the only thing that the compiler says?
Another compiler warns about your friend too:

14:67: warning: friend declaration 'std::ostream& operator<<(std::ostream&, const linkedListType<Type>&)' declares a non-template function [-Wnon-template-friend]
14:67: note: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) 
 In member function 'void linkedListType<Type>::insertFirst(const Type&)':
125:22: warning: suggest braces around empty body in an 'if' statement [-Wempty-body]
 In instantiation of 'void linkedListType<Type>::copyList(const linkedListType<Type>&) [with Type = int]':
316:26:   required from 'const linkedListType<Type>& linkedListType<Type>::operator=(const linkedListType<Type>&) [with Type = int]'
333:10:   required from here
272:9: warning: statement has no effect [-Wunused-value]
/tmp/ccREhTuH.o: In function `main':
:(.text.startup+0xd2): undefined reference to `operator<<(std::ostream&, linkedListType<int> const&)'
:(.text.startup+0x195): undefined reference to `operator<<(std::ostream&, linkedListType<int> const&)'
:(.text.startup+0x24a): undefined reference to `operator<<(std::ostream&, linkedListType<int> const&)'
collect2: error: ld returned 1 exit status

[coder777]

The problem is that the compiler does not consider the declaration on line 14 and the definition on line 72 related. If you want a friend function within a templated class you need to define that friend function entirely within the templated class.

[AbstractionAnon]

Line 14: Your output operator is private.

Line 332,334,339: You're trying to invoke a private operator from a non-member.

Line 34: Your comment indicates the following 3 lines are protected, but you don't declare them protected.

Line 125: What's the point of this line? It does nothing.

Lines 167-173: I strongly recommend braces around these lines to indicate the scope of your while statement along with proper indentation to clearly indicate your intent.

Line 272: This line does nothing. Pretty sure you meant an assignment here, not a comparison.