stack-c++

#include <iostream>

using namespace std;


template <typename T>
class Stack{
private:
	int size;
	int capacity;
	int top_loci;
	T *data;

public:
	~Stack();
	Stack(int size = 100);
	void pop();
	void push(const T value);
	int get_stack_size();
	void clear();
	bool empty();
	bool full();
	void expand_size();
	T top();
};

template<typename T>
Stack<T>::Stack(int size){
	top_loci = -1;
	size = 0;
	capacity = size;
	data = new T[size];
}

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

	data = nullptr;
	capacity = 0;
	size = 0;
	top_loci = -1;
}

template<typename T>
void Stack<T>::push(const T value){
	if(full()){
		expand_size();
	}

	size++;
	data[++top_loci] = value;
}

template<typename T>
void Stack<T>::pop(){
	if(empty()){
		std::cerr<<"empty stack"<<endl;
	}

	size--;
	top_loci--;
}

template<typename T>
T Stack<T>::top(){
	if(empty()){
		return 0;
	}

	return data[top_loci];
}

template<typename T>
int Stack<T>::get_stack_size(){
	return size;
}

template<typename T>
bool Stack<T>::empty(){
	return top_loci==-1;
}

template<typename T>
void Stack<T>::clear(){
	size = 0;
	top_loci = -1;
}

template<typename T>
bool Stack<T>::full(){
	return capacity==size;
}

template<typename T>
void Stack<T>::expand_size(){
	T *p = new T[2*capacity];
	for(int i=0;i<capacity;i++)
		p[i] = data[i];

	capacity = 2*capacity;
	delete data;
	data = p;
}



void print_stack(Stack<int> s){
	while(!s.empty()){
		cout<<s.top()<<" ";
		s.pop();
	}
	cout<<endl;
}

int main(int argc, char const *argv[]){
	Stack<int> s(100);
	s.push(1);
	s.push(2);
	s.push(3);
	s.push(4);
	cout<<s.top()<<endl;
	print_stack(s);
	s.pop();
	s.push(8);
	cout<<s.top()<<endl;
	return 0;
}