FIFO Queue with Templates

[k007]

This is part of an assignment that I am doing. I have to create a Queue (FIFO) using templates. I have been able to create that and it works. There is one more part to this same assignment where I am unable to figure out how to proceed. Here is what I need to do -

Add a second template parameter that specifies the data structure to be used in the template Stack class. The implementation should be container based (use any one from STL).

Here is an extract from the first part of code (creating Queue with template so it can be used with char, int, float):

class Stack
{
public:
        Stack(int=5); // Constructor
        ~Stack(); // Destructor
        void push(const T); // add a character to the back of the queue
        bool empty() const; // test if the queue is empty
        bool full() const; // test if the queue is full
        T pop(); // remove a character from the front of the queue
        T front() const; // check, but do not remove, the character at the front of the queue
        int size() const; // returns the number of elements in the queue
        void shrink(); // resize the queue to be as small as possible
        void expand(); // Expand the queue to accomodate more characters
        int capacity(); // returns the number of elements allocated
        void resize(int); // resize the queue by adding some elements;
private:
        T *_data;
        int _capacity;
        int _front; // = 0;
        int _back; // = 0;
        int _size; // = 0;
        static const int _EMPTY = -1;
        static const int _DEFAULT = 5;
};


template <class T>
Stack<T>::Stack(int capacity)
{
        if (capacity < 0)
        {
                _capacity = _DEFAULT;
        }
        else
        {
                _capacity = capacity; // Total size of the array
                _data = new T[_capacity]; // Allocate memory for the array
                _front = 0;
                _back = 0;
                _size = 0;
        }
}


template <class T>
Stack<T>::~Stack()
{
        delete [] _data;
}

template <class T>
bool Stack<T>::empty() const
{
        return _size == 0;
}

template <class T>
bool Stack<T>::full() const
{
        return _size == _capacity;
}

template <class T>
void Stack<T>::push(const T c)
{
        if (_size==_capacity) expand();
        _data[_back] = c;
        if (_back++==_capacity-1) _back=0;
        _size++;
}


template <class T>
T Stack<T>::pop()
{
        if (_size==0) return _EMPTY;
        T c = _data[_front];
        if (_front++==_capacity-1) _front=0;
        _size--;
        return c;
}

How should I proceed converting the same stuff above to use another template parameter that specifies the data structure to be used in the template Stack class? How will the function definitions change?

Thanks
k

[mrnutty]

I think your template deceleration should look something like this :

template<typename Type1,typename Cont = vectors<int> >
class Stack { ... }

[k007]

Thanks for the response.

So in that case how will the function definitions look like? I mean what will change in the following part?

template <class T>
void Stack<T>::push(const T c)
{
.
.
.
}

Thanks
k