Question

I’m trying to tempalitize a linkedlist(/stack/queue) to accept int and double. But so far I can’t get my code to work. (I took out the list/queue member functions to simply try and get it to work/not give errors when building. So it’s mainly just the stack stuff.) Without the “template stuff” code works fine. If I missed anything or need to add anything LMK!

Errors I get our:

1>LinkedList_Stack.obj : error LNK2019: unresolved external symbol “public: __thiscall NumberList::~NumberList(void)” (??1?$NumberList@H@@QAE@XZ) referenced in function _main

1>LinkedList_Stack.obj : error LNK2019: unresolved external symbol “public: void __thiscall NumberList::pop(int &)” (?pop@?$NumberList@H@@QAEXAAH@Z) referenced in function _main

1>LinkedList_Stack.obj : error LNK2019: unresolved external symbol “public: void __thiscall NumberList::push(int)” (?push@?$NumberList@H@@QAEXH@Z) referenced in function _main

1>F:\Documents and Settings\Riotson\Desktop\LinkList\LinkedList_Stack_Queue_BNS11\Debug\LinkedList_Stack_Queue_BNS11.exe : fatal error LNK1120: 3 unresolved externals

I read 3 different post on this site and tried to mimic that for tempaltizing (Where to place the ‘s and what not) but couldnt’ get it to work =. Help please!!!

List.h:

#ifndef LIST_H
#define LIST_H
template<class T>
struct ListNode
{
    T value;    // Value in this node
    struct ListNode<T> *next; // Pointer to the next node
};

    // Class of LinkedList/Stack/Queue
template<class T>
class NumberList
{
private:
    ListNode<T> *head, *rear; // List head pointer

public:
    //Constructor
    NumberList()
    { head = NULL; rear = NULL; }

    //Destructor
    ~NumberList();

    // Linked List Operations
    void displayList() const;

    //Stack operations
    void push(T);
    void pop(T &);
    bool isEmpty();
};

template<class T>
void NumberList<T>::displayList() const
{
    ListNode *nodePtr;

    nodePtr = head;

    while(nodePtr)
    {
        cout << nodePtr->value << endl;

        nodePtr = nodePtr->next;
    }
}
template<class T>
NumberList<T>::~NumberList()
{
    ListNode<T> *nodePtr;
    ListNode<T> *nextNode;

    // Position nodePtr at the head of the list
    nodePtr = head;

    // While nodePtr is not at the end of the list....
    while(nodePtr != NULL)
    {
        // Save a pointer to the next node.
        nextNode = nodePtr->next;

        // Delete the current node.
        delete nodePtr;

        // Position nodePtr at the next node.
        nodePtr = nextNode;
    }
}

template<class T>
void NumberList<T>::push(T num)
{
    ListNode<T> *newNode; // Point to a new node

    // Allocate a new node and store num there.
    newNode = new ListNode;
    newNode->value = num;

    //If there are no nodes in the list
    // make newNode the first node.
    if(isEmpty())
    {
        head = newNode;
        newNode->next = NULL;
    }
    else
    {
        newNode->next = head;
        head = newNode;
    }
}

template<class T>
void NumberList<T>::pop(T &num)
{
    ListNode<T> *temp; // Temporary pointer

    // First make sure stack isn't empty.
    if(isEmpty())//Create a DynIntQueue object.
    {
        cout << "The stack is empty.\n";
    }
    else // pop value off the top of stack
    {
        num = head->value;
        temp = head->next;
        delete head;
        head = temp;
    }
}

// Member function isEmpty returns true if the stack/Queue
//is empty, or false otherwise.
template<class T>
bool NumberList<T>::isEmpty()
{
    bool status;

    if(!head)
        status = true;
    else
        status = false;

    return status;
}
#endif

Main:

#include "List.h"
int main()
{   int catchVar; // To hold value popped off the stack

    // Create a Dynamic IntStack object.
    NumberList<int> stack;

    // Push values onto stack
    cout << "Pushing 1, 2, 3\n";
    stack.push(1);
    stack.push(2);
    stack.push(3);

    cout << endl;

    // Pop the values off the stack
    cout << "Popping...\n";
    stack.pop(catchVar);
    cout << catchVar << endl;
    stack.pop(catchVar);
    cout << catchVar << endl;
    stack.pop(catchVar);
    cout << catchVar << endl;

    // Try to pop another value off the stack.
    cout << "\nAttempting to pop again... " <<endl;
    stack.pop(catchVar);
    cout << endl;

    // Templitization of a Double
    cout << "Pushing a double of 1.5\n";
    stack.push(1.5);

    cout << endl;
    cout << "Popping double 1.5...\n";
    stack.pop(catchVar);
    cout << catchVar << endl;

    cout << "Templitization Succesful\n" << endl;
    cout << endl;

    return 0;
}

Answer 1

Don’t put template functions in a .cpp. Put them in with the header file.