Опишите класс, реализующий стек (Stack)

#include <iostream>
#include <stack>
 
template<class T>
class Stack
{
    std::stack<T> m_stack;
public:
    void push(const T& val)
    {
        m_stack.push(val);
    }
    void pop()
    {
        return m_stack.pop();
    }
    void printStack()
    {
        using base = decltype(m_stack);
        struct acces : public base { using base::c; };
        for (auto const& val : m_stack.*&acces::c)
            std::cout << val << std::endl;
    }
    size_t getStackSize()
    {
        return m_stack.size();
    }
};

#include <stdexcept>
#include <iostream>
#include <iomanip>
 
 
template<typename T>
class Stack {
public:
    Stack(size_t size) : maximum(size), data(new T[maximum]), size(0) {}
    Stack(const Stack<T>& o) : maximum(o.maximum), data(new T[maximum]), size(o.size) {
        std::copy(o.data, o.data + size, data);
    }
    Stack<T>& operator=(const Stack<T>& o) {
        if (this != &o) {
            if (data != nullptr) {
                delete[] data;
            }
            maximum = o.maximum;
            data = new T[maximum];
            size = o.size;
            std::copy(o.data, o.data + size, data);
        }
        return *this;
    }
    virtual ~Stack() {
        if (data != nullptr) {
            delete[] data;
        }
    }
    bool isEmpty() const { return size == 0; }
    size_t getSize() const { return size; }
    T& top() {
        assertUnderflow();
        return data[size - 1];
    }
    const T& top() const {
        assertUnderflow();
        return data[size - 1];
    }
    void push(const T& value) {
        assertOverflow();
        data[size++] = value;
    }
    void push(T&& value) {
        assertOverflow();
        data[size++] = std::move(value);
    }
    void pop() {
        assertUnderflow();
        data[--size];
    }
    T& operator[](size_t i) {
        return data[i];
    }
    const T& operator[](size_t i) const {
        return data[i];
    }
private:
    void assertUnderflow() {
        if (isEmpty()) {
            throw new std::underflow_error("not enough data in stack");
        }
    }
    void assertOverflow() {
        if (size >= maximum) {
            throw new std::overflow_error("stack overflow");
        }
    }
    size_t maximum;
    T* data;
    size_t size;
};
 
template<typename T>
std::ostream& operator<<(std::ostream& out, const Stack<T>& s) {
    for (size_t i = 0; i < s.getSize(); ++i) {
        out << s[i];
        if (i < s.getSize() - 1) {
            out << ", ";
        }
    }
    return out;
}
 
int main(int argc, char** argv) {
    Stack<std::string> s(10);
    s.push("aaa");
    s.push("bbb");
    std::cout << "TOP: " << s.top() << std::endl;
    std::cout << "CONTENT: " << s << std::endl;
    std::cout << "POP" << std::endl;
    s.pop();
    std::cout << "TOP: " << s.top() << std::endl;
    std::cout << "CONTENT: " << s << std::endl;
 
    return 0;
}