数据结构::模拟实现动态栈

#include<iostream>
#include<assert.h>
using namespace std;
//动态栈

template<typename T>
class Stack
{
public:
	Stack()                      //构造函数
		:arr(NULL)
		,_size(0)
		,_capacity(0)
	{}
	Stack(const Stack<T>& s)   //拷贝构造函数
		:arr(NULL)
		,_size(s._size)
		,_capacity(s._capacity)
	{
		arr = new int[s._capacity];
		for(size_t i = 0; i<s._size; i++)
		{
			arr[i] = s.arr[i];
		}
	}
	Stack<T>& operator=(const Stack<T>&s)     //赋值运算符重载
	{
		if(this != &s)
		{
			_capacity = _capacity*2+3;
			T*temp = new int[s._capacity];
			for(size_t i = 0; i<s._size; i++)
			{
				temp[i] = s.arr[i];
			}
			delete[]arr;
			arr = temp;
			_size = s._size;
			_capacity = s._capacity;
		}
		return *this;
	}
	~Stack()      // 析构函数
	{
		delete[]arr;
		_size = 0;
		_capacity = 0;
	}

public:
	void CheckCapacity()        //检查动态栈的容量是否已满   
	{
		if(_size>=_capacity)
		{
			T *temp = new int[_capacity*2+3];
			for(size_t i = 0; i<_size; i++)
				{
					temp[i] = arr[i];
				}
				delete[] arr;
			arr = temp;
			_capacity =  _capacity*2+3;
			
		}
	}
		
	void Push(const T& x)     //压栈
	{
		CheckCapacity();
		arr[_size] = x;
		++_size;
	}
	void Pop()          // 出栈
	{
		assert(arr);
		--_size;
	}
	T& Top()             //返回栈顶的元素
	{
		return arr[_size-1];
	}
	const T& Top()const
	{
		return arr[_size-1];
	} 
	size_t Size()               //求栈的有效存储元素
	{
		return _size;
	}
	bool Empty()            //检查栈是否为空
	{
		return _size==0;
	}

protected:
        T*arr;
	size_t _size;       //有效元素
	size_t _capacity;    //动态栈的总容量
};
//测试基本函数
void Funtest1()
{
	Stack<int> s1;
	Stack<int> s2(s1);
	Stack<int> s3;
	s3 = s2;
}
//测试插入删除函数
void Funtest2()
{
	Stack<int> s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	while(!s.Empty())
	{
		cout<<s.Top()<<" ";
		s.Pop();
	}	
}
//测试后面的函数
void Funtest3()
{
	Stack<int> s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	s.Size();
	
}
int main()
{
	//Funtest1();
	//Funtest2();
	Funtest3();
	return 0;
}