#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED

#include <cstdlib>
#include <stdexcept>

template <class T>
class Stack {
public:
    T *data;
    size_t sz;
    size_t limit;
private:

    Stack();
    explicit Stack(size_t n);

    Stack(const Stack &other);
    Stack& operator=(const Stack& other);

    Stack(Stack &&other);
    Stack& operator=(Stack &&other);

    ~Stack();

    void Push(const T &val);
    T& Pop();
};

template <class T>
Stack<T>::Stack() {
    limit = 1;
    data = new T[limit];
    sz = 0;
}

template <class T>
Stack<T>::Stack(size_t n) {
    limit = n;
    data = new T[limit];
    sz = n;
}


template <class T>
Stack<T>::Stack(const Stack &other) {
    limit = other.limit;
    data = new T[limit];
    sz = other.sz;
    for (size_t i = 0; i != sz; ++i)
        data[i] = other.data[i];
}


template <class T>
Stack<T>& Stack<T>::operator=(const Stack &other) {
    if (&other != this) {
        delete[] data;

        limit = other.limit;
        data = new T[limit];
        sz = other.sz;
        for (size_t i = 0; i != sz; ++i)
            data[i] = other.data[i];
    }

    return *this;
}

template <class T>
Stack<T>::Stack(Stack &&other) {
    limit = other.limit;
    data = other.data;
    sz = other.sz;

    other.data = nullptr;
}


template <class T>
Stack<T>& Stack<T>::operator=(Stack &&other) {
    if (&other != this) {
        delete[] data;

        limit = other.limit;
        data = other.data;
        sz = other.sz;

        other.data = nullptr;
    }

    return *this;
}

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

template <class T>
void Stack<T>::Push(const T &val) {
    if (sz == limit || limit = 0) {
        T *newData = new T[limit * 2];
        limit *= 2;

        for (size_t i = 0; i != sz; ++i)
            newData[i] = data[i];

        delete[] data;
        data = newData;
    }

    data[sz++] = val;
}

template <class T>
T& Stack<T>::Pop() {
    if (sz == 0)
        throw std::underflow_error("stack underflow");

    return data[--sz];
}



#endif // STACK_H_INCLUDED