Как реализовать Stack, Queue, ArrayList?

#include <iostream>
 
using namespace std;
 
#include "Queue.h" // подключаем шаблон класса
 
int main()
{
    Queue<char> myQueue(5); // объект класса очередь
 
    myQueue.printQueue(); // вывод очереди
 
    int ct = 1;
    char ch;
 
    // добавление элементов в очередь
    while (ct++ != 5)
    {
        cin >> ch;
        myQueue.push(ch);
    }
 
    myQueue.printQueue(); // вывод очереди
 
    // удаление элемента из очереди
    cout << "\nRemove two elements from the stack\n";
    myQueue.pop();
    myQueue.pop();
 
    myQueue.printQueue(); // вывод очереди
 
    cout << "\n\nLoad the copy constructor!\n";
    Queue<char> newQueue(myQueue);
 
    newQueue.printQueue(); // вывод очереди
 
    system("pause");
    return 0;
}

#ifndef QUEUE_H
#define QUEUE_H
#include <cassert> // для assert
#include <iostream>
#include "interface.PushPopContainer.h"
 
template <class T>
class Queue : public PushPopContainer<T>{
private:
    T *arr; // указатель на очередь
    const int size; // Емкость очереди
    int begin, end; // начало, конец очереди
    int elemCT; //счетчик элементов
public:
    Queue(int = 10); //размер очереди = 10 элементам
    Queue(const Queue<T> &); // конструктор копирования
    ~Queue();
 
    inline void push(const T &); // добавить элемент в очередь
    inline T pop(); // удалить элемент из очереди
    inline void printQueue(); // вывод очереди
    inline const T &Peek(int) const; // n-й элемент от вершины очереди
    inline int Size() const;  // получить размер очереди
    inline bool isEmpty() const; // пуста ли очередь
    };
 
// конструктор по умолчанию
template <class T>
Queue<T>::Queue(int sizeQueue) : size(sizeQueue), // инициализация константы
begin(0), end(0), elemCT(0)
{
    // дополнительная позици поможет нам различать конец и начало очереди
    arr = new T[size + 1];
}
 
// конструктор копирования
template<class T>
Queue<T>::Queue(const Queue &otherQueue) :
size(otherQueue.size), begin(otherQueue.begin),
end(otherQueue.end), elemCT(otherQueue.elemCT),
arr(new T[size + 1])
{
    for (int ix = 0; ix < size; ix++)
        arr[ix] = otherQueue.arr[ix]; // копируем очередь
}
 
// деструктор класса Queue
template<typename T>
Queue<T>::~Queue(){ delete[] arr; }
 
// функция добавления элемента в очередь
template <class T>
inline void Queue<T>::push(const T &newElem){
    // проверяем, ести ли свободное место в очереди
    assert(elemCT < size);
 
    // обратите внимание на то, что очередь начинает заполняться с 0 индекса
    arr[end++] = newElem;
 
    elemCT++;
 
    // проверка кругового заполнения очереди
    if (end > size)
        end -= size + 1; // возвращаем end на начало очеред
}
 
// функция удаления элемента из очереди
template<typename T>
inline T Queue<T>::pop()
{
    // проверяем, есть ли в очереди элементы
    assert(elemCT > 0);
 
    T returnValue = arr[begin++];
    elemCT--;
 
    // проверка кругового заполнения очереди
    if (begin > size)
        begin -= size + 1; // возвращаем behin на начало очереди
 
    return returnValue;
}
 
// функция возвращает n-й элемент от вершины очереди
template <class T>
inline const T &Queue<T>::Peek(int nom) const{
    //
    assert(nom <= end);
    return arr[end - nom]; // вернуть n-й элемент стека
}
 
// вывод стека на экран
template <class T>
inline void Queue<T>::printQueue(){
    cout << "Queue: ";
    if (end == 0 && begin == 0)
        cout << " is Empty \n";
    else
    {
        for (int ix = end; ix >= begin; ix--)
            cout << arr[ix] << " ";
        cout << endl;
    }
}
 
// вернуть размер очереди
template <class T>
inline int Queue<T>::Size() const { return size; }
 
template <class T>
inline bool Queue<T>::isEmpty() const { return !size; }
 
#endif // QUEUE_H