实现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;
};