Класс queue и stack на суд для знающих

#include <iostream>
using namespace std;
template<typename type>
class MyQueue {
private:
    type* wait;         //Очередь
    int maxLength;      //Максимальный размер очереди
    int length;         //Текущий размер очереди
public:
    MyQueue();          //Конструктор
    MyQueue(int m);     //Конструктор с размером очереди
    void add(type c);   //Добавление элемента    
    type extract();     //Извлечение элемента
    void clear();       //Очистка очереди
    bool is_empty();    //Проверка существования элементов в очереди
    bool is_full();     //Проверка на переполнение очереди
    int get_count();    //Количество элементов в очереди
    void show();        //демонстрация очереди
    ~MyQueue();         //Деструктор                       
};
 
template<typename type>
inline MyQueue<type>::MyQueue()
{
    maxLength = 0;
    length = 0;
}
 
template<typename type>
inline MyQueue<type>::MyQueue(int m)
{
    length = 0;
    maxLength = m;
    this->wait = new type[m];
}
 
template<typename type>
inline void MyQueue<type>::add(type c)
{
    this->wait[length] = c;
    length++;
}
 
template<typename type>
inline type MyQueue<type>::extract()
{
    type x = this->wait[0];
    this->wait++;
    this->length--;
    this->maxLength--;
    return x;
}
 
template<typename type>
inline void MyQueue<type>::clear()
{
    delete[] this->wait;
    this->wait = new type[maxLength];
    this->length = 0;
}
 
template<typename type>
inline bool MyQueue<type>::is_empty()
{
    if (this->wait)
        return false;
    else
        return true;
}
 
template<typename type>
inline bool MyQueue<type>::is_full()
{
    if (this->maxLength == this->length)
        return true;
    else
        return false;
}
 
template<typename type>
inline int MyQueue<type>::get_count()
{
    return length;
}
 
template<typename type>
inline void MyQueue<type>::show()
{
    if (wait) {
        for (int i = 0; i < length; i++) {
            cout << "[" << i << "] = " << wait[i] << endl;
        }
        cout << endl;
    }
}
 
template<typename type>
inline MyQueue<type>::~MyQueue()
{
    if (wait)
        delete[] wait;
}
 
 
template<typename type>
class MyStack {
    type* data;             // Массив для хранения данных
    int _top;               // Указатель на вершину стека
    
public:
    MyStack();                  // Конструктор по умолчанию
    MyStack(int size);          // Конструктор для инициализации размера стека
    MyStack(const MyStack& st);     // Конструктор копирования
    MyStack(MyStack&& st);          // Конструктор переноса
 
    bool empty()const;          // Пустой стек?                       
    void push(type& val);       // Добавление элемента в конец стека
    int size()const;            // Количество элементов в стеке
    void pop();                 // Удаление последнего элемента в стеке
    const type& top()const;     // Возврат последнего элемента в стеке
    void swap(MyStack& val);        // Обмен 2х стеков местами
 
    ~MyStack();                 // Деструктор
};
 
template<typename type>
inline MyStack<type>::MyStack()
{
    this->_top = 0;
}
 
template<typename type>
inline MyStack<type>::MyStack(int size)
{
    this->data = new type[size];
    this->_top = 0;
}
 
template<typename type>
inline MyStack<type>::MyStack(const MyStack& st)
{
    this->data = type[this->_top];
    this->_top = st._top;
    for (int i = 0; i < this->_top; i++) {
        this->data[i] = st.data[i];
    }
}
 
template<typename type>
inline MyStack<type>::MyStack(MyStack&& st)
{
    this->data = type[this->_top];
    this->_top = st._top;
    for (int i = 0; i < this->_top; i++) {
        this->data[i] = st.data[i];
    }
    st.data = nullptr;
}
 
template<typename type>
inline bool MyStack<type>::empty() const
{
    if (this->data)
        return true;
    else
        return false;
}
 
template<typename type>
inline void MyStack<type>::push(type& val)
{
    this->data[this->_top] = val;
    this->_top++;
}
 
template<typename type>
inline int MyStack<type>::size() const
{
    return this->_top;
}
 
template<typename type>
inline void MyStack<type>::pop()
{
    if (this->_top == 0) {}
    else {
        --this->_top;
    }
}
 
template<typename type>
inline const type& MyStack<type>::top() const
{
    return this->data[this->_top - 1];
}
 
template<typename type>
inline void MyStack<type>::swap(MyStack& val)
{
    for (int i = 0; i < this->_top; i++) {
        type x = this->data[i];
        this->data[i] = val.data[i];
        val.data[i] = x;
    }
}
 
template<typename type>
inline MyStack<type>::~MyStack()
{
    if (this->data)
        delete[] this->data;
}
 
 
int main()
{
    MyStack<int> *a = new MyStack<int>(10);
    for (int i = 0; i < 5; i++) {
        a->push(i);
    }
 
    for (int i = 0; i < 5; i++) {
        cout << a->top() << "  ";
        a->pop();
    }
    cout << endl;
 
    /////////////////////////////////////////
    MyQueue<int>* b = new MyQueue<int>(10);
    for (int i = 0; i < 5; i++) {
        b->add(i);
    }
    b->show();
 
    for (int i = 0; i < 5; i++) {
        b->extract();
    }
    b->show();
 
    cin.get();
    cin.get();
    return 0;
}

int main()
{
    MyStack<int> *a = new MyStack<int>(10);
    MyStack<int> aa(*a);

template<typename type>
inline MyStack<type>::MyStack(MyStack&& st)
: data(st.data)
, _top(st._top)
{
    st.data = nullptr;
}