Не могу обнаружить ошибку в учебной программе из книги (шаблоны классов)

#include <iostream>
using namespace std;
template<typename type>
class List
{
    public:
        void print();
};
 
template<typename type>
void List<type>::print()
{
    cout  << "print\n";
}
 
int main()
{
    List<int> l();
    l.print();
    return 0;
}

List<int> l;

#include <assert.h>
#include <iostream>
 
using namespace std;
 
template<typename NODETYPE>
class ListNode;
 
template<typename NODETYPE>
class List
{
    public:
        List();
        ~List();
        void insertAtFront(const NODETYPE &);
        void insertAtBack(const NODETYPE &);
        int removeFromFront(NODETYPE &);
        int removeFromBack(NODETYPE &);
        int isEmpty() const;
        void print() const;
    private:
        ListNode<NODETYPE>* firstPtr;
        ListNode<NODETYPE>* lastPtr;
        ListNode<NODETYPE>* getNewNode(const NODETYPE &);
};
 
template<typename NODETYPE>
class ListNode
{
    template<NODETYPE> friend class List;
 
    public :
        ListNode(const NODETYPE &);
        NODETYPE getData() const;
    private:
        NODETYPE data;
        ListNode* nextPtr;
};
 
 
//конструктор
template<typename NODETYPE>
List<NODETYPE>::List()
{
    firstPtr = lastPtr = NULL;
}
 
//пуст ли список
template<typename NODETYPE>
int List<NODETYPE>::isEmpty() const
{
    return firstPtr == NULL;
}
 
//деструктор
template<typename NODETYPE>
List<NODETYPE>::~List()
{
    if(!isEmpty())
        cout << "Удаление узлов.\n";
 
    ListNode<NODETYPE>* currentPtr, * tempPtr;
 
    while(currentPtr != NULL)
    {
        tempPtr = currentPtr;
        cout << tempPtr->data << endl;
        currentPtr = currentPtr->nextPtr;
        delete tempPtr;
    }
 
    cout << "Все узлы удалены.\n";
}
 
//вставка в начало списка
template<typename NODETYPE>
void List<NODETYPE>::insertAtFront(const NODETYPE& value)
{
    ListNode<NODETYPE>* newPtr = getNewNode(value);
    if(isEmpty())
        firstPtr = lastPtr = newPtr;
    else
    {
        newPtr->nextPtr = firstPtr;
        firstPtr = newPtr;
    }
 
}
 
//новый узел списка
template<typename NODETYPE>
ListNode<NODETYPE>* List<NODETYPE>::getNewNode(const NODETYPE& value)
{
    ListNode<NODETYPE>* ptr = new ListNode<NODETYPE>(value);
    assert(ptr != NULL);
    return ptr;
}
 
//вставка в конец списка
template<typename NODETYPE>
void List<NODETYPE>::insertAtBack(const NODETYPE& value)
{
    ListNode<NODETYPE>* newPtr = getNewNode(value);
    if(isEmpty())
        firstPtr = lastPtr = newPtr;
    else
    {
        lastPtr->nextPtr = newPtr;
        lastPtr = newPtr;
    }
}
 
//удаление из начала списка
template<typename NODETYPE>
int List<NODETYPE>::removeFromFront(NODETYPE& value)
{
    if(isEmpty())
        return 0;
    else
    {
        ListNode<NODETYPE>* tempPtr = firstPtr;
        if(firstPtr == lastPtr)
        {
            firstPtr = lastPtr = NULL;
        }
        else
        {
            firstPtr = firstPtr->nextPtr;
        }
 
        value = tempPtr->data;
        delete tempPtr;
 
        return 1;
    }
}
 
//удаление из конца списка
template<typename NODETYPE>
int List<NODETYPE>::removeFromBack(NODETYPE& value)
{
    if(isEmpty())
        return 0;
    else
    {
        ListNode<NODETYPE>* tempPtr = lastPtr;
        if(firstPtr == lastPtr)
        {
            firstPtr = lastPtr = NULL;
        }
        else
        {
            ListNode<NODETYPE>* currentPtr = firstPtr;
            while(currentPtr->nextPtr != lastPtr)
                currentPtr = currentPtr->nextPtr;
            lastPtr = currentPtr;
            lastPtr->nextPtr = NULL;
        }
 
        value = tempPtr->data;
        delete tempPtr;
        return 1;
    }
}
 
 
//вывод списка
template<typename NODETYPE>
void List<NODETYPE>::print() const
{
    if (isEmpty())
    {
        cout << "Список пуст\n";
        return;
    }
 
    ListNode<NODETYPE>* currentPtr = firstPtr;
    cout << "Список состоит из:\n";
 
    while (currentPtr != NULL)
    {
        cout << currentPtr->data << ' ';
        currentPtr = currentPtr->nextPtr;
    }
    cout << endl << endl;
}
 
//конструктор
template<typename NODETYPE>
ListNode<NODETYPE>::ListNode(const NODETYPE& info)
{
    data = info;
    nextPtr = NULL;
}
 
//возвращает данные из узла
template<typename NODETYPE>
NODETYPE ListNode<NODETYPE>::getData()const
{
    return data;
}
 
 
void instructions()
{
    cout << "1 - Вставить в начало" << endl;
    cout << "2 - Вставить в конец" << endl;
    cout << "3 - Удалить из начала" << endl;
    cout << "4 - Удалить из конца" << endl;
    cout << "5 - Завершить обработку" << endl;
}
 
void testInteger()
{
    cout << "Integer\n";
    List<int> iList;
 
    instructions();
    int choise, value;
    do
    {
        cin >> choise;
        switch (choise)
        {
            case 1 :
            {
                cout << "Введите целое: ";
                cin >> value;
                iList.insertAtFront(value);
                iList.print();
                break;
            }
            case 2 :
            {
                cout << "Введите целое: ";
                cin >> value;
                iList.insertAtBack(value);
                iList.print();
            }
            case 3 :
            {
                if(iList.removeFromFront(value))
                    cout << value << " удаляется из списка\n";
                iList.print();
                break;
            }
            case 4 :
            {
                if(iList.removeFromBack(value))
                    cout << value << " удаляется из списка\n";
                iList.print();
                break;
            }
        }
    }
    while(choise != 5);
    cout << "Конец проверки целых чисел.\n";
 
}
 
int main()
{
    testInteger();
    return 0;
}

template<typename NODETYPE>
class ListNode
{
    friend class List<NODETYPE>;
 
    public :
        ListNode(const NODETYPE &);
        NODETYPE getData() const;
    private:
        NODETYPE data;
        ListNode* nextPtr;
};

/*template<NODETYPE> */friend class List<NODETYPE>;