stack by dynamic arrays

#include <bits/stdc++.h>

using namespace std;
template <typename T>
struct my_stack{
public:

    void push(T value) {
        if (stack_size == data_size) {
            resize();
        }
        data[stack_size++] = value;
    }

    void pop() {
        if (stack_size > 0)
            --stack_size;
    }

    T top() {
        if (stack_size == 0)
            throw out_of_range("stack is empty");
        return data[stack_size - 1];
    }

    size_t size() {
        return stack_size;
    }

    bool empty() {
        return stack_size == 0;
    }

    void clear() {
        stack_size = 0;
        data_size = 1;
        delete [] data;
        data = new T[data_size];
    }

    void change_reserve_size(size_t reserve_size) {
        if (stack_size >= reserve_size)
            throw length_error("reserve size is smaller then stack size");
        resize(reserve_size);
    }

    ~my_stack() {
        delete [] data;
    }

    my_stack() : data(new T[data_size]) {}

    explicit my_stack(size_t reserve_size) : data(new T[reserve_size]), data_size(reserve_size) {}

private:

    size_t data_size = 1;
    size_t stack_size = 0;
    T* data;

    void resize(size_t new_size) {
        T* new_data = new T[new_size];
        memcpy(new_data, data, stack_size * sizeof(T));
        data_size = new_size;
        delete [] data;
        data = new_data;
    }

    void resize() {
        resize(data_size * 2);
    }
};

int main() {
    my_stack<int> s(100);
    int a;
    cin >> a;
    for (int i = 0; i < a; ++i) {
        int t;
        cin >> t;
        if (t == 0) {
            int b;
            cin >> b;
            s.push(b);
        } else if (t == 1) {
            cout << s.top() << endl;
        } else if (t == 2) {
            cout << s.size() << endl;
        } else if (t == 3) {
            s.pop();
        }
    }
    return 0;
}