An error on a certain line of code from the memorandum of a tutor

[Bopaki]

Write your question here.
Is there an error or this line or not?

  Put the code you need help with here.
 friend ostream& operator<< <>(ostream&, const linkedListType<Type>&);

[keskiverto]

Probably, but without context I won't dare to say.

What does your compiler say? Any error's or warnings?


Does it have to be a friend? What non-public parts of the class does it need?

[AbstractionAnon]

Are linkedListType and Type are defined?

friend ostream& operator<< <>(ostream&, const linkedListType<Type>&);
What's with the <> ?

[Bopaki]

//Here is the complete header file:
#ifndef LINKEDLISTTYPE_H
#define LINKEDLISTTYPE_H

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

template<class Type>
class linkedListType;

template<class Type>
 ostream& operator<<(ostream, const linkedListType<Type>&);

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>&);
		        //Overload the assignment operator.
		void initializeList();
			   //Initializes the list to an empty state.
			   //Postcondition: first = NULL, last = NULL;
			     //             count = 0;
		bool isEmptyList();
				//Function to determine whether the list is empty.
				//Postcondition: Returns true is the list is empty;
				//               otherwise returns false.
		int length();
			//Function to return the number of nodes in the list.
			//Postcondition: The value of count is returned.
		void destroyList();
			//Function to delete all the nodes from the list
			//Postcondition:  first = NULL, last = NULL,
			//                count = 0;
		Type front();
			//Function to return the first element of the list.
			//Precondition: The list must exist and must not be empty.
			//Postcondition: If the list is empty, then the
			//                progream terminates, otherwise,
			//                the first element of the list is returned
		Type back();
			//Function to return the last element of the list.
			//Precondition: The list must exist and must not be empty
			////Postcondition: If the list is empty, then the
			//                progream terminates, otherwise,
			//                the last element of the list is returned			
	   bool search(const Type& searchItem);
	   		//Function to determine whether searchItem is in the list
			//Postcondition: Returns true of searchItem is found in the list
			//                  otherwise it returns false
		void insertFirst(const Type& newItem);
			//Function to insert newItem in the list
			//PostCondition: first points to the new list and newItem is
			//              is inserted at the beginning of the list
		void insertLast(const Type& newItem);
				//Function to insert newItem at the end of the llist
			//PostCondition: first points to the new list and newItem is
			//              is inserted at the end of the list, and last points
			//              to the last node in the list
		void deleteNode(const Type& deleteItem);
			//Function to delete deleteItem from the list
			//Postcondition: IF found, the node containing deleteItemis deleted
			//               from the list, first point to the first node, and last
			//               points to the last nodeof the updated list.
		void deleteAll(const Type& deleteItem);
			//Delete all occurrences of a given element
		void deleteSmallest();
			//Find and delete the node with the smallest info
		
		linkedListType();
			   //default constructor
			   //Initializes the list to an empty state.
			   //Postcondition: first = NULL, last = NULL,
			   //                count = 0;
		linkedListType(const linkedListType<Type>& otherList);
				//copy constructor
		~linkedListType();
				//destructor
				//Deletes all the nodes from the list.
				//Postcondition: The list object is destroyed
	protected:
		int count;       //variable to store the number of elements
						// in the list
		nodeType<Type> *first;    //pointer to the first node of the list
		nodeType<Type> *last;     ////pointer to the last node of the list
	
	private:
		void copyList(const linkedListType<Type>& otherList);
			//Function to make a copy of otherlist.
			//Postcondition: A copy of otherList is created
			//              and assigned to this list
			};
#endif 

[keskiverto]

See the section Template friend operators in: http://en.cppreference.com/w/cpp/language/friend
friend ostream& operator<< <>(ostream&, const linkedListType& );

[AbstractionAnon]

@keskiverto - Thanks.

[Bopaki]

Here is another example of this friend function.
When I compile this code I get this error:
18 68 C:\Martin\MalikChapter3\LinkedList.h [Warning] friend declaration 'std::ostream& operator<<(std::ostream&, const linkedListType<Type>&)' declares a non-template function [-Wnon-template-friend]
18 68 C:\Martin\MalikChapter3\LinkedList.h [Note] (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here)

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 deleteNode(const Type& deleteItem);

    linkedListType(); 

    linkedListType(const linkedListType<Type>& otherList); 

    ~linkedListType();   

protected:
    int count;      //variable to store the number of 
                //elements in the list
    nodeType<Type> *first; //pointer to the first node of 
                           //the list
    nodeType<Type> *last;  //pointer to the last node of 
                           //the list 
private:
    void copyList(const linkedListType<Type>& otherList); 
};
#endif 

[keskiverto]

Ahh, now we have seen three versions of the friendship:

friend ostream& operator<< <>    (ostream&, const linkedListType<Type>&); // your
friend ostream& operator<<       (ostream&, const linkedListType<Type>&); // your
friend ostream& operator<< <>    (ostream&, const linkedListType      &); // cppreference
friend ostream& operator<< <Type>(ostream&, const linkedListType      &); // cppreference 

You did read the explanations at the cppreference.com site, did you?


@AbstractionAnon: I was equally clueless about the <> before websearch reached cppref*