By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
448,562 Members | 1,298 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 448,562 IT Pros & Developers. It's quick & easy.

HELP can not link my template class

P: 2
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


Expand|Select|Wrap|Line Numbers
  1. bool test();
  2.  
  3. template <class  T>
  4. class queue
  5. {
  6. public:
  7.     // construct a queue
  8.     queue(int item_size, int queue_len);
  9.     // deconstructor
  10.  
  11.     ~queue(){};
  12.  
  13.     // post an item onto the queue
  14.     bool post(T* item);
  15.  
  16.     // get next item from queuw
  17.  
  18.     bool get(T* item);
  19.  
  20.     // wait for timeout for item
  21.  
  22.     bool get_wait(T* item, unsigned int timeout = 0);
  23.  
  24.     int item_queued(T* item);
  25.  
  26. private:
  27.     int _que;
  28. };
  29.  
  30. template <class T>
  31. queue<T>::queue(int item_size, int queue_len)
  32. {
  33.     test();
  34. };
  35.  
  36. template <class T>
  37. bool queue<T>::post(T* item)
  38. {
  39.     return test();
  40. }
  41.  
  42. // return the current value of the semaphore count
  43. template <class T>
  44. bool queue<T>::get(T* item)
  45. {
  46.     return test();
  47. }
  48.  
  49. // wait for the semaphore count to go above zero
  50. template <class T>
  51. bool queue<T>::get_wait(T* item, unsigned int timeout)
  52. {
  53.     return test();
  54. }
  55.  
  56. template <class T>
  57. int queue<T>::item_queued(T* item)
  58. {
  59.     return test();
  60. };
  61.  
  62. bool test()
  63. {
  64.     return true;
  65. }
  66.  
  67. int main ()
  68. {
  69.  
  70.     queue<int> myqueue(2,3);
  71.     return 1;
  72. }
  73.  this is the file that wont link
  74.  
  75.  
  76. namespace os {
  77.  
  78. // CLASSES ///////////////////////////////////////////////////////////////////
  79.  
  80. // abstraction of an operating system semaphore, allowing the counting of 
  81. // resources between threads.  
  82.  
  83. class semaphore
  84. {
  85. public:
  86.     // construct a semaphore
  87.  
  88.     semaphore(int value = 0);
  89.  
  90.     // deconstructor
  91.  
  92.     ~semaphore();
  93.  
  94.     // increment the semaphore count by one.  if it was previously non-zero 
  95.     // and someone was waiting on it, the waiting thread will be woken up
  96.  
  97.     void post();
  98.  
  99.     // return the current value of the semaphore count
  100.  
  101.     int get();
  102.  
  103.     // wait for the semaphore count to go above zero
  104.  
  105.     bool wait(unsigned int timeout = 0);
  106.  
  107.     // acquire semaphore lock if count is above zero and return true. if lock
  108.     // not available returns false immediately
  109.  
  110.     bool try_wait();
  111.  
  112. private:
  113.     ak_sem_t _sem;
  114. };
  115.  
  116. template <class  T>
  117. class queue
  118. {
  119. public:
  120.     // construct a queue
  121.     queue(int item_size, int queue_len);
  122.  
  123.     // deconstructor
  124.  
  125.     ~queue(){};
  126.  
  127.     // post an item onto the queue
  128.     bool post(T* item);
  129.  
  130.     // get next item from queuw
  131.  
  132.     bool get(T* item);
  133.  
  134.  
  135.     // wait for timeout for item
  136.  
  137.     bool get_wait(T* item, unsigned int timeout = 0);
  138.  
  139.  
  140.     int items_queued();
  141.  
  142. private:
  143.     ak_queu_t _que;
  144. };
  145. // NAMESPACE END /////////////////////////////////////////////////////////////
  146.  
  147. };
  148.  
  149. .cpp file is
  150. semaphore::semaphore(int value)
  151. {
  152.     ak_sem_create(&_sem, value);
  153. }
  154.  
  155. // deconstructor
  156.  
  157. semaphore::~semaphore()
  158. {
  159.     ak_sem_free(&_sem);
  160. }
  161.  
  162. // increment the semaphore count by one.  if it was previously non-zero 
  163. // and someone was waiting on it, the waiting thread will be woken up
  164.  
  165. void semaphore::post()
  166. {
  167.     ak_sem_post(&_sem);
  168. }
  169.  
  170. // return the current value of the semaphore count
  171.  
  172. int semaphore::get()
  173. {
  174.     return ak_sem_get(&_sem);
  175. }
  176.  
  177. // wait for the semaphore count to go above zero
  178.  
  179. bool semaphore::wait(unsigned int timeout)
  180. {
  181.     return ak_sem_wait(&_sem, timeout) == 1 ? true : false;
  182. }
  183.  
  184. // acquire semaphore lock if count is above zero and return true. if lock
  185. // not available returns false immediately
  186.  
  187. bool semaphore::try_wait()
  188. {
  189.     return ak_sem_trywait(&_sem) == 1 ? true : false;
  190. }
  191.  
  192. //////////////////////////////////////////////////////////////
  193. // increment the semaphore count by one.  if it was previously non-zero 
  194. // and someone was waiting on it, the waiting thread will be woken up
  195.  
  196. template <class T>
  197. queue<T>::queue(int item_size, int queue_len)
  198. {
  199.     ak_que_setup(&_que, item_size, queue_len);
  200. };
  201.  
  202. template <class T>
  203. bool queue<T>::post(T* item)
  204. {
  205.     return (bool)ak_que_post(_que,(const void*)item);
  206. }
  207.  
  208. // return the current value of the semaphore count
  209. template <class T>
  210. bool queue<T>::get(T* item)
  211. {
  212.     return (bool)ak_que_get(_que, (void*)item);
  213. }
  214.  
  215. // wait for the semaphore count to go above zero
  216. template <class T>
  217. bool queue<T>::get_wait(T* item, unsigned int timeout)
  218. {
  219.     return ak_que_wait(_que, (void*)item, timeout) == 1 ? true : false;
  220. }
  221.  
  222. template <class T>
  223. int queue<T>::items_queued()
  224. {
  225.     return ak_que_get_num_items(_que);
  226. };
  227.  
the sem class complies and links fine jsut not the template class.

please help. very stuck
Nov 13 '08 #1
Share this Question
Share on Google+
1 Reply


Banfa
Expert Mod 5K+
P: 8,916
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.
Nov 14 '08 #2

Post your reply

Sign in to post your reply or Sign up for a free account.