Template Class in C++: Simple Queue Class Example

In this tutorial, I would like to demonstrate C++ template class by providng a very simple Queue class example.

The following shows its source file queue.cpp and header file queue.hpp:

	#include <cassert>
	#include <cstddef>
	template<typename T>
	Queue<T>::Queue(int maxSize) :
	maxSize(maxSize),
	head(0),
	tail(0),
	numElems(0) {
	assert(maxSize > 0);
	queue = new T[maxSize * sizeof *queue];
	assert(queue != NULL);
	}
	template<typename T>
	Queue<T>::Queue(const Queue& that) :
	maxSize(0),
	queue(NULL) {
	*this = that;
	}
	template<typename T>
	Queue<T>::~Queue() {
	delete[] queue;
	}
	template<typename T>
	Queue<T>& Queue<T>::operator=(const Queue& that) {
	if (that.maxSize > maxSize) {
	if (queue != NULL)
	delete[] queue;
	queue = new T[that.maxSize * sizeof *queue];
	assert(queue != NULL);
	}
	maxSize = that.maxSize;
	head = that.head;
	tail = that.tail;
	numElems = that.numElems;
	for (int idx=0; idx<=numElems; idx++) {
	queue[(head+idx)%maxSize] = that.queue[(head+idx)%maxSize];
	}
	return *this;
	}
	template<typename T>
	int Queue<T>::numQueued() {
	return numElems;
	}
	template<typename T>
	int Queue<T>::enqueue(const T& t) {
	if (numElems >= maxSize)
	return -1;
	queue[head] = t;
	head = (head+1)%maxSize;
	numElems++;
	return 0;
	}
	template<typename T>
	int Queue<T>::dequeue(T* t) {
	if (numElems <= 0 || t == NULL)
	return -1;
	*t = queue[tail];
	tail = (tail+1)%maxSize;
	numElems--;
	return 0;
	}

view raw queue.cpp hosted with ❤ by GitHub

	#ifndef __QUEUE_HPP__
	#define __QUEUE_HPP__
	template<typename T>
	class Queue {
	public:
	Queue(const Queue& that);
	Queue(int maxSize);
	~Queue();
	int enqueue(const T& t);
	int dequeue(T* t);
	Queue &operator=(const Queue& that);
	int numQueued();
	private:
	T *queue;
	int head, tail, numElems;
	int maxSize;
	};
	#include "queue.cpp"
	#endif

view raw queue.hpp hosted with ❤ by GitHub

There are a couple of important things to note.

First, the header file actually #includes the source file. This is because Queue class is a template class. In C++, a template class declaration and definition cannot be separated, and therefore by #includeing the source file, the two files are effectively treated as a single file. Of course, you may choose to simply define all the methods in the header file and get rid of the queue.cpp file.

Second, copy constructor, copy operator, and destructors are defined explicitly, because it assigns dynamic memory allocation. Please refer to this post for more details on the Rule of Three.

Lastly, when you compile sources that make use of this template class, all you need to do is to #include the header file. For instance, the compile command should look like:
$ g++ main.cpp

Notice there is no need to compile queue.cpp file or queue.hpp file separately. All you need to do is to make sure that queue.hpp file #includes queue.cpp file, and main.cpp #includes queue.hpp file.