#pragma once
#include "stack.h"
#include <iostream>

template <class T>
class arrayStack : public Stack<T> {
private:
	T* stack;
	int stackTop;
	int length;
public:
	arrayStack(int initialCapacity = 10);
	virtual ~Stack() { delete[] stack; }

	virtual bool empty() const override { return stackTop == -1; }
	virtual int size() const override { return stackTop + 1; }
	virtual T& top() override;
	virtual void pop() override;
	virtual void push(const T& theElement) override;
};

template <class T>
arrayStack<T>::arrayStack(int initialCapacity) {
	length = initialCapacity;
}


template <class T>
T& arrayStack<T>::top() {
	if (stackTop == -1)	throw std::invalid_argument("No Element in Stack");
	return stack[stackTop];
}

template <class T>
void arrayStack<T>::pop() {
	if (stackTop == -1) throw std::invalid_argument("Empty Stack");
	if constexpr (!std::is_trivially_destructible<T>::value) {
		stack[stackTop].~T();  // 只有在 T 有析构函数时才调用
	}
	stackTop--;
}

template <class T>
void arrayStack<T>::push(const T& theElement) {

}