Question

I am trying to define a vector < Queue >. this vector should contain the starting address of each queue object. I have created a copy constructor and an assignment operator within the List.h (queue has private: list). However even before my program runs, it raises the error : List.h:156:1: error: invalid use of template-name ‘List’ without an argument list

Here is the code (arrowed out the relevant bits)

#ifndef LIST_H
#define LIST_H
#include "ListNode.h"

using namespace std;
template <typename NODETYPE>
class List {
public:
    List(const List&);                    <-----------copy constructor 
    List();
    ~List();
    void insertAtFront(const NODETYPE& );
    void insertAtBack (const NODETYPE& );
    bool removeFromFront(NODETYPE& );
    bool removeFromBack (NODETYPE& );
    bool isEmpty() const;
    void print() const;
    int length() const;
    List<NODETYPE>& operator=(const List&);     <----- assignment operator overload (see end)
private:
    ListNode<NODETYPE> *firstPtr;
    ListNode<NODETYPE> *lastPtr;
    ListNode<NODETYPE> *getNewNode (const NODETYPE& );
};

template <typename NODETYPE>                <------------code for copy constructor
List<NODETYPE>::List(const List& source){
    firstPtr = source.firstPtr;
    lastPtr = source.lastPtr;}


template <typename NODETYPE>
List<NODETYPE>::List():firstPtr(0),lastPtr(0){}

template <typename NODETYPE>
List<NODETYPE>::~List(){
    if (!isEmpty()){
        cout<<"\nDestroying node ... \n";
        ListNode<NODETYPE> *currentPtr = firstPtr;
        ListNode<NODETYPE> *tmpPtr;
        while (currentPtr != 0){
            tmpPtr = currentPtr;
            cout<<tmpPtr->value<<endl;
            currentPtr = currentPtr->nextPtr;
            delete tmpPtr;
        }
        }
    cout<<"\nAll node destroyed\n";
    }

template <typename NODETYPE>
void List<NODETYPE>::insertAtFront(const NODETYPE &val){
    ListNode<NODETYPE>*newPtr = getNewNode(val);
    if (isEmpty()){
        firstPtr = lastPtr = newPtr;}
    else {
        newPtr ->nextPtr = firstPtr;
        firstPtr = newPtr;                                          // do not understand this frag
    }}

template <typename NODETYPE>
void List<NODETYPE>::insertAtBack(const NODETYPE& val){
        ListNode<NODETYPE>*newPtr = getNewNode(val);
    if (isEmpty()){
        firstPtr = lastPtr = newPtr;}
    else {
        lastPtr ->nextPtr =newPtr;
        lastPtr = newPtr;                                           // do not understand this frag
    }

}

template <typename NODETYPE>
bool List<NODETYPE>::removeFromFront(NODETYPE& data)
{
    if (isEmpty()){
        return false;}
    else
    {
        ListNode<NODETYPE> *tempPtr = firstPtr;
        if (firstPtr == lastPtr)
            firstPtr = lastPtr = 0;
        else
            firstPtr = firstPtr->nextPtr;           // must look at detail inside DDD, what happens to the current ListNode object pointed to byfirstPtr
        data = tempPtr->value;
        delete tempPtr;
        return true;
    }
}
template <typename NODETYPE>
bool List<NODETYPE>::removeFromBack (NODETYPE& data) {

    if (isEmpty){
        return false;}
    else
    {
        ListNode<NODETYPE> *tempPtr = firstPtr;
        if (firstPtr == lastPtr)
            firstPtr = lastPtr = 0;
        else
        {
            ListNode<NODETYPE> *currentPtr = firstPtr;
            while (currentPtr->nextPtr !=lastPtr){
                currentPtr = currentPtr->nextPtr; }
            lastPtr = currentPtr;
            currentPtr ->nextPtr = 0;
        }
        data= tempPtr->value;
        delete tempPtr;
        return true;
    }
    }

template <typename NODETYPE>
bool List<NODETYPE>::isEmpty() const{                               // CONSTANT MEMBER FUNCTION
    return firstPtr==0;
    }

                                                                // different from textbook (see p 755)
template <typename NODETYPE>
ListNode<NODETYPE>* List<NODETYPE>::getNewNode(const NODETYPE&value) {
    return new ListNode <NODETYPE>(value); }



template<typename NODETYPE>
void List<NODETYPE>::print() const {
    if (isEmpty()) {
        cout<<" This list is empty\n";
        return ;}
    ListNode<NODETYPE> *currentPtr = firstPtr;
    while (currentPtr !=0)
    {
        cout << currentPtr->value <<' ';
        currentPtr = currentPtr->nextPtr;
        }
    cout<< "\n\n";

}

template <typename NODETYPE>
int List<NODETYPE>::length() const {
    if (this->isEmpty()){
        cout<< "\n Return size of what ? .. this list is empty ";
        return 0; }
    int size = 1;
    ListNode<NODETYPE>* currentPtr = firstPtr;
    while (currentPtr != lastPtr) {
        currentPtr = currentPtr->nextPtr;
        size +=1;
        }
    return size;
}

 template<typename NODETYPE>                       
List<NODETYPE>& List<NODETYPE>::operator=(List& rhs)       <---- line of error
{
    if (this !=&rhs){
        this->firstPtr = rhs.firstPtr;
        this->lastPtr = rhs.lastPtr; 
        return &firstPtr;
    }

   #endif

Calling program is as follows:

#include <iostream>List& operator=(const List&);
#include <vector>
#include "Queue.h"
#include <algorithm>
using namespace std;

int main () {
    vector < Queue <int> > dodo;
    for (int init = 0; init<4;init++ ){
        dodo.push_back(init);
    vector <Queue <int> >::const_iterator iterator;
    for (iterator = dodo.begin();iterator !=dodo.end();iterator ++){
        cout<<"Address of each queue item "<<dodo[]<<'\t'<<&dodo[];}
    int dequeueInteger;
    Queue <int> intQueue;
    cout <<"\n Size is .. " <<intQueue.howbig();
    cout << "\nProcessing integer Queue\n";
    for (int i=0;i<3;++i) {
        intQueue.enqueue(i);
        intQueue.printQueue(); }
    Queue<int> photo;
    photo = intQueue;

    cout <<"\n\n Here is mr. photo";
    photo.printQueue();

cout<<endl<<"\nSize of this queue is .. " <<intQueue.howbig();
cout<<endl;
while (!intQueue.isQueueEmpty()){
    intQueue.dequeue(dequeueInteger);
    cout<<dequeueInteger<<" dequeued\n";
    intQueue.printQueue();
}
}

file Queue.h

    #ifndef QUEUE_H
#define QUEUE_H
#include "List.h"

template <typename QUEUETYPE>
class Queue : private List< QUEUETYPE >
{
public:
void enqueue (const QUEUETYPE &data) {
    insertAtBack(data);}
bool dequeue (QUEUETYPE &data) {
    return removeFromFront(data); }
bool isQueueEmpty ()const {
    return this->isEmpty(); }
void printQueue() const {
    this ->print(); }
int howbig() const {
    return this->length();
    }


};
   #endif 

Answer 1

You’re missing the template argument to the return value

template<typename NODETYPE>                       
List<NODETYPE>& List<NODTETYPE>::operator=(List& rhs)
    ^^^^^^^^^^

You need that, because the compiler doesn’t know he’s parsing a List member, where List means the current template instantiation, until after List<NODETYPE>::.