c++ 链式栈的简单实现

template<typename T>
class CStack
{
public:
	CStack(void);
	CStack(const CStack& _stack);
	CStack& operator=(const CStack& _stack);
	~CStack();
public:
	inline T top(void)const;
	inline bool empty(void)const;
	inline size_t get_size(void)const;
	void push(const T& data);
	void pop(void);
	void clear(void);
	void print(void)const;
private:
	void copy(const CStack& _stack);
private:
	struct CStack_item
	{
	public:
		CStack_item(void) = default;
		CStack_item(const T& _data);
		CStack_item(const CStack_item& _item) = delete;
		CStack_item& operator = (const CStack_item& _item) = delete;
	public:
		T data;
		CStack_item* next;
	};
private:
	CStack_item* head;
	size_t size;
};

template<typename T>
CStack<T>::CStack_item::CStack_item(const T& _data) :next(nullptr), data(_data) {}


template<typename T>
CStack<T>::CStack(void) :head(nullptr), size(0) {}

template<typename T>
CStack<T>::CStack(const CStack& _stack) : head(nullptr), size(0)
{
	this->copy(_stack);
}
template<typename T>
CStack<T>& CStack<T>:: operator=(const CStack& _stack)
{
	if (this == &_stack)
	{
		return *this;
	}
	clear();
	this->copy(_stack);

	return *this;
}

template<typename T>
CStack<T>::~CStack()
{
	clear();
}

template<typename T>
void CStack<T>::copy(const CStack& _stack)
{
	auto p = _stack.head;
	while (p != nullptr)
	{
	
		push(p->data);
		p = p->next;
	}
}

template<typename T>		//读取
T CStack<T>::top(void)const
{
	return head->data;
}

template<typename T>
bool CStack<T>:: empty(void)const
{
	return size == 0;
}

template<typename T>
size_t CStack<T>::get_size(void)const
{
	return size;
}

template<typename T>
void CStack<T>::push(const T& data)   //压入
{
	auto head_item =new  CStack_item(data);
	head_item->next = head;
	head = head_item;
	size++;
}

template<typename T>
void CStack<T>::pop(void)		//弹出
{
	auto p = head;
	head = head->next;
	delete p;
	size--;
}

template<typename T>
void CStack<T>::clear(void)
{
	auto p = head;
	while (!empty())
	{
		pop();
	}
	
}
template<typename T>
void CStack<T>::print(void)const
{
	auto p = head;
	while (p != nullptr)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

int main()
{
	CStack<int> stack1;
	for (int i = 0; i < 10; i++)
	{
		stack1.push(i);
	}
	stack1.print();
	CStack<int> stack2(stack1);
	stack2.print();
	cout << stack1.get_size() << endl;


	return 0;
}