实现Stack的基本操作

简单来说，栈是一种特殊的线性表，只允许在固定一端（栈顶）进行插入和删除元素的操作。因此栈又被称为后进先出的线性表。下面就来看看它可以进行哪些基本的操作。在进行扩容时，如果是对栈中基本数据类型的操作我们使用浅拷贝memcpy，否则用=进行拷贝，所以在这里用到了类型萃取。下面看一下代码实现。

/实现Stack的基本操作//
扩容时 类型萃取
struct _TrueType
{
	static bool Get()
	{
		return true;
	}
};
struct _FalseType
{
	static bool Get()
	{
		return false;
	}
};
template<typename T>
struct TypeTraits
{
	typedef _FalseType IsPOD;
};
template<>
struct TypeTraits<int>
{
	typedef _TrueType IsPOD;
};
template<>
struct TypeTraits<float>
{
	typedef _TrueType IsPOD;
};
template<>
struct TypeTraits<double>
{
	typedef _TrueType IsPOD;
};
template<>
struct TypeTraits<long>
{
	typedef _TrueType IsPOD;
};
template<>
struct TypeTraits<char>
{
	typedef _TrueType IsPOD;
};
template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 10)
		:_capacity(capacity)
	{
		_pData = NULL;
		_size = 0;
	}
	Stack(const Stack<T>& s)
	{
		_pData = s._pData;
		_size = s._size;
		_capacity = s._capacity;
	}
	Stack<T>& operator=(const Stack<T>& s)
	{
		if(this != &s)
		{
			_pData = s._pData;
			_size = s._size;
			_capacity = s._capacity;
		}
		return *this;
	}
	void Push(const T& x)
	{
		_CheckCapacity();
		_pData[_size++] = x;
	}
	void Pop()
	{
		assert(_size);
		--_size;
	}
	size_t Size()const
	{
		return _size;
	}
	T& Top()
	{
		return _pData[_size-1];
	}
	const T& Top()const
	{
		return _pData[_size-1];
	}
	bool Empty()const
	{
		return _size==0;
	}

private:
	void _CheckCapacity()
	{
		if(_size == capacity)
		{
			T* temp = new[_capacity*2+2];//申请空间 注意要加个常数

			if(TypeTraits<T>::IsPOD::Get())//如果为POD类型
			{
				memcpy(temp, _pData, sizeof(T)*_size);//用memcpy拷贝元素
			}
			for(int idx = 0; idx < _size; idx++)//不是POD类型则 用for循环一个一个拷贝元素
			{
				temp[idx] = _pData[idx];
			}
			delete[] _pData;//释放旧空间
			_pData = temp;//指向新空间
		}
		_capacity = _capacity*2+2;//容量变为新的容量
	}
	T* _pData;
	size_t size;
	size_t capacity;
};