HELP can not link my template class

[Ajb181]

hi all. i have a template class that i can not link. there is no problem when i add the method def's inside the header file but as soon as i move them out i get a link error where i define the object. i have tryed a simple test of the same code and it links fine so am baffeled at what is happing

this is my simple test that complies and links

bool test();
 
template <class  T>
class queue
{
public:
    // construct a queue
    queue(int item_size, int queue_len);
    // deconstructor
 
    ~queue(){};
 
    // post an item onto the queue
    bool post(T* item);
 
    // get next item from queuw
 
    bool get(T* item);
 
    // wait for timeout for item
 
    bool get_wait(T* item, unsigned int timeout = 0);
 
    int item_queued(T* item);
 
private:
    int _que;
};
 
template <class T>
queue<T>::queue(int item_size, int queue_len)
{
    test();
};
 
template <class T>
bool queue<T>::post(T* item)
{
    return test();
}
 
// return the current value of the semaphore count
template <class T>
bool queue<T>::get(T* item)
{
    return test();
}
 
// wait for the semaphore count to go above zero
template <class T>
bool queue<T>::get_wait(T* item, unsigned int timeout)
{
    return test();
}
 
template <class T>
int queue<T>::item_queued(T* item)
{
    return test();
};
 
bool test()
{
    return true;
}
 
int main ()
{
 
    queue<int> myqueue(2,3);
    return 1;
}
 this is the file that wont link
 
 
namespace os {
 
// CLASSES ///////////////////////////////////////////////////////////////////
 
// abstraction of an operating system semaphore, allowing the counting of 
// resources between threads.  
 
class semaphore
{
public:
    // construct a semaphore
 
    semaphore(int value = 0);
 
    // deconstructor
 
    ~semaphore();
 
    // increment the semaphore count by one.  if it was previously non-zero 
    // and someone was waiting on it, the waiting thread will be woken up
 
    void post();
 
    // return the current value of the semaphore count
 
    int get();
 
    // wait for the semaphore count to go above zero
 
    bool wait(unsigned int timeout = 0);
 
    // acquire semaphore lock if count is above zero and return true. if lock
    // not available returns false immediately
 
    bool try_wait();
 
private:
    ak_sem_t _sem;
};
 
template <class  T>
class queue
{
public:
    // construct a queue
    queue(int item_size, int queue_len);
 
    // deconstructor
 
    ~queue(){};
 
    // post an item onto the queue
    bool post(T* item);
 
    // get next item from queuw
 
    bool get(T* item);
 
 
    // wait for timeout for item
 
    bool get_wait(T* item, unsigned int timeout = 0);
 
 
    int items_queued();
 
private:
    ak_queu_t _que;
};
// NAMESPACE END /////////////////////////////////////////////////////////////
 
};
 
.cpp file is
semaphore::semaphore(int value)
{
    ak_sem_create(&_sem, value);
}
 
// deconstructor
 
semaphore::~semaphore()
{
    ak_sem_free(&_sem);
}
 
// increment the semaphore count by one.  if it was previously non-zero 
// and someone was waiting on it, the waiting thread will be woken up
 
void semaphore::post()
{
    ak_sem_post(&_sem);
}
 
// return the current value of the semaphore count
 
int semaphore::get()
{
    return ak_sem_get(&_sem);
}
 
// wait for the semaphore count to go above zero
 
bool semaphore::wait(unsigned int timeout)
{
    return ak_sem_wait(&_sem, timeout) == 1 ? true : false;
}
 
// acquire semaphore lock if count is above zero and return true. if lock
// not available returns false immediately
 
bool semaphore::try_wait()
{
    return ak_sem_trywait(&_sem) == 1 ? true : false;
}
 
//////////////////////////////////////////////////////////////
// increment the semaphore count by one.  if it was previously non-zero 
// and someone was waiting on it, the waiting thread will be woken up
 
template <class T>
queue<T>::queue(int item_size, int queue_len)
{
    ak_que_setup(&_que, item_size, queue_len);
};
 
template <class T>
bool queue<T>::post(T* item)
{
    return (bool)ak_que_post(_que,(const void*)item);
}
 
// return the current value of the semaphore count
template <class T>
bool queue<T>::get(T* item)
{
    return (bool)ak_que_get(_que, (void*)item);
}
 
// wait for the semaphore count to go above zero
template <class T>
bool queue<T>::get_wait(T* item, unsigned int timeout)
{
    return ak_que_wait(_que, (void*)item, timeout) == 1 ? true : false;
}
 
template <class T>
int queue<T>::items_queued()
{
    return ak_que_get_num_items(_que);
};
 

the sem class complies and links fine jsut not the template class.

please help. very stuck

[Banfa]

The definitions of the methods of a template class have to be in the header file with the class declaration, or at least must be included at the same time that the class is included.

Remember the template class is not a class but a pattern that instructs the compiler how to produce a class once the template parameters are given. If the method definitions are not there at the time the code uses the class and thus the compiler tries to create a class following the template then the compiler can not create a complete class so you get errors.


Also please use [code],,,[/code] tags round your posted code, it makes it more readable.