Смоделировать очередь с помощью масива

int * a = new int[размер];

#include <iostream>
using namespace std;
 
template<class T> class stack{
public:
    stack(int s);
 
    void push(T);
    T pop();
 
    void print();
 
    bool EMPTY;
    bool FULL;
private:
    int size; //Размер выделяемого массива
    int count; //Элементов в этом массиве
 
    T * elements;
};
template<class T> stack<T>::stack(int s)
{
    count = 0;
    size = s;
 
    EMPTY = true;
    FULL = false;
 
    elements = new T[size];
}
template<class T> void stack<T>::push(T item)
{
    if(FULL)
    {
        cout << "Cant do it!" << endl;
        return;
    }
    EMPTY = false;
 
    elements[count] = item;
    count++;
    if (count == size-1)
        FULL = true;
}
template<class T> T stack<T>::pop()
{
    if (EMPTY)
    {
        cout << "Cant do it!" << endl;
        return T();
    }
    count--;
    if(count == 0)
        EMPTY = true;
    return elements[count+1];
}
template<class T> void stack<T>::print()
{
    for(int a=0;a<count;a++)
        cout << "Element " << a << " = " << elements[a] << " ;" << endl;
}
int main(int argc, char* argv[])
{
    system("pause");
    return 0;
}

#include <iostream>
#include <iomanip>
 
const int STEP = 10;
 
template <class T>
class Queue
{
public:
    Queue();
    Queue(const int); 
    ~Queue();
    void push(const T);
    T pop();
    int size() const;
    bool isEmpty() const;
    T& front();
    T& back();
    
private:
    T *queue;
    T *begin;
    T *end;
    int queueSize;
    int count;
};
 
template <class T>
Queue<T>::Queue(): queueSize(STEP), count(0)
{
    queue = new T [queueSize];
    begin = &queue[0];
    end = &queue[0];
}
 
template <class T>
Queue<T>::Queue(const int size): queueSize(size), count(0)
{
    if(queueSize <= 0)
        queueSize = STEP;
    queue = new T [queueSize];
    begin = &queue[0];
    end = &queue[0];
}
 
template <class T>
Queue<T>::~Queue()
{
    delete[] queue;
}
 
template <class T>
void Queue<T>::push(const T num)
{
    if((end - 1) != &queue[queueSize - 1])
    {
        *(end) = num;
        ++end;
    }
    else
    {
        int cnt = end - begin;
        if(begin == &queue[0])
            queueSize += STEP;
        T *buf = new T [cnt];
        for(int i = 0; i < cnt; ++i)
            buf[i] = *(begin + i);
        delete[] queue;
        queue = new T [queueSize];
        begin = &queue[0];
        end = &queue[0];
        for(int i = 0; i < cnt; ++i)
        {
            *end = buf[i];
            ++end;
        }
        *(end) = num;
        ++end;
        delete[] buf;
    }
}
 
template <class T>
T Queue<T>::pop()
{
    ++begin;
    return *(begin - 1);
}
 
template <class T>
int Queue<T>::size() const
{
    return end - begin;
}
 
template <class T>
bool Queue<T>::isEmpty() const
{
    return ((end - begin) == 0);
}
 
template <class T>
T& Queue<T>::front()
{
    return *begin;
}
 
template <class T>
T& Queue<T>::back()
{
    return *(end - 1);
}
 
int main()
{
    Queue<int> q;
    for(int i = 0; i < 20; ++i)
        q.push(i + 1);
    /*while(!q.isEmpty())
        std::cout << q.pop() << std::setw(6);*/
    std::cout << q.front() << ' ' << q.back() << '\n';
    q.front()++;
    q.back()--;
    std::cout << q.front() << ' ' << q.back() << '\n';
    return 0;
}

int num;
while(std::cin >> num)
    q.push(num);