Linking problems using templates in in a linked list class

Hej!

Jeg har en linked list, som gerne skal laves med templates, så jeg ikke skal lave 117 kopier af den..

Jeg har lavet flg, som også kan kompileres, men under linkningen siger den:
/tmp/ccxCR5Za.o: In function `main':
/tmp/ccxCR5Za.o(.text+0x3e): undefined reference to `CFIFOQueue<int>::CFIFOQueue(int)'
/tmp/ccxCR5Za.o(.text+0x55): undefined reference to `CFIFOQueue<int>::~CFIFOQueue(void)'
/tmp/ccxCR5Za.o(.text+0x1f9): undefined reference to `CFIFOQueue<int>::~CFIFOQueue(void)'

OS er FreeBSD 4.7 STABLE
Ikke helt holdbart vel..
Egentlig er der også en Mutexwrapper klasse med, men den har jeg fjernet for ikke også at skulle poste koden for den også...
Jeg vil prøve og få en kopi af koden til at ligge på http://www.trillegaarden.cjb.net/coding/problem.html

Her er koden:

------------ test.cc ---------------
#include <iostream.h>
#include "CFIFOQueue.h"

int main()
{
    int *data = new int;
    *data = 1;
    CFIFOQueue< int > queueue(*data);

    cout << "\nProgram finishing\n";
    return 1;
}

------- CFIFOQueue.h -----------------------
#ifndef CFIFOQueue_h
#define CFIFOQueue_h

#include <assert.h>

//Forward declaration
template< class NODETYPE > class CFIFOQueue;

template<class NODETYPE>
class QueueNode
{
    friend class CFIFOQueue< NODETYPE >;    //Make CFIFOQueue a friend
public:
    QueueNode( NODETYPE *data );
    NODETYPE *getData();
private:
    NODETYPE *data;
    QueueNode< NODETYPE > *nextPtr;
};

template< class NODETYPE >
class CFIFOQueue
{
public:
    CFIFOQueue(int i);
    ~CFIFOQueue();

    bool    get(NODETYPE *data);
    void    put(NODETYPE *data);
    bool    isEmpty() const;

private:
    QueueNode< NODETYPE > *firstPtr;
    QueueNode< NODETYPE > *lastPtr;

    QueueNode< NODETYPE > *getNewNode( NODETYPE *data);
};
#endif


-------- CFIFOQueue.cc -----------------------------
#include <iostream.h>
#include "CFIFOQueue.h"


template<class NODETYPE>
QueueNode< NODETYPE >::QueueNode( NODETYPE *data )     { this->data = data; this->nextPtr = 0; }

template<class NODETYPE>
NODETYPE *QueueNode< NODETYPE >::getData()             { return this->data; }





template< class NODETYPE >
CFIFOQueue< NODETYPE >::CFIFOQueue(int i)
{
    this->firstPtr = this->lastPtr = 0;
    cout << "Constructor has been run..\n";

}


template< class NODETYPE >
CFIFOQueue< NODETYPE >::~CFIFOQueue()
{
    if(!this->isEmpty() )
    {
        cout << "Killing all nodes..\n";

        QueueNode< NODETYPE > *currentPtr = this->firstPtr, tempPtr;

        while(currenPtr != 0)
        {
            tempPtr = currentPtr;
            currentPtr = currentPtr->next;
            delete tempPtr;
        }
    }
    cout << "All entries destroyed..\n";
}


template< class NODETYPE >
void CFIFOQueue< NODETYPE >::put(NODETYPE *data)
{
    QueueNode< NODETYPE > *newPtr = this->getNewNode( data );

    if( this->isEmpty() )         this->firstPtr = this->lastPtr = newPtr;
    else
    {
        newPtr->nextPtr = this->firstPtr;
        this->firstPtr = newPtr;
    }
}



template< class NODETYPE >
bool CFIFOQueue< NODETYPE >::get(NODETYPE *data)
{
    bool succes;

    if( this->isEmpty() )         succes = 0;
    else
    {
        QueueNode< NODETYPE > *tempPtr = this->lastPtr;
        if(this->firstPtr == tempPtr)         this->firstPtr = this->lastPtr = 0;
        else
        {
            QueueNode< NODETYPE > *currentPtr = this->firstPtr;

            while(currenPtr->nextPtr != this->lastPtr)    currentPtr = currentPtr->next;

            this->lastPtr = currentPtr;
            this->lastPtr->nextPtr = 0;
        }
        data = tempPtr->data;
        succes = 1;
        delete tempPtr;
    }
    return succes;
}

template< class NODETYPE >
QueueNode< NODETYPE > *CFIFOQueue< NODETYPE >::getNewNode(NODETYPE *data)
{
    QueueNode< NODETYPE > *newPtr = new QueueNode< NODETYPE >( data );

    assert( newPtr != 0 );
    return newPtr;
}

template< class NODETYPE >
bool CFIFOQueue< NODETYPE >::isEmpty() const
{
    return (this->firstPtr == 0);
}