栈的基本操作

#include <iostream>
#include<string>
#include <assert.h>
using namespace std;

struct _TrueType
{
    static int Get() //使用static修饰成员函数的话，访问该成员函数的话可以用通过类作用域访问，
        //不使用static修饰成员函数的话，访问该成员函数，要先进行对象的创建，然后用成员操作符访问
    {
        return true;
    }
};

struct _FalseType
{
    static int Get()
    {
        return false;
    }
};

template<class T>
struct TypeTraits
{
    typedef _FalseType ISPODType;//POD:plain old data 平凡类型（无关痛痒的类型）--基本类型
};

template<>
struct TypeTraits<int>
{
    typedef _TrueType ISPODType;
};

template<>
struct TypeTraits<char>
{
    typedef _TrueType ISPODType;
};

template<>
struct TypeTraits<double>
{
    typedef _TrueType ISPODType;
};

template<>
struct TypeTraits<long>
{
    typedef _TrueType ISPODType;
};


//使用萃取判断类型的Get函数判断是否是 POD类型来处理 
template <class T> 
void Copy(const T* src ,T* dest, size_t size) 
{     
    cout<<"_TrueType:"<<typeid(T).name()<<endl;
    if(TypeTraits<T>::ISPODType::Get())    
    {         
        memcpy(dest ,src, size);    
    }     
    else    
    {         
        for (size_t i=0; i<size; ++i)
        {             
            dest[i] = src[ i];        
        }    
    } 
}



template<class T>
class Stack
{
public:
    Stack()
        :_pData(new T[3])
        ,_size(0)
        ,_capacity(3)
    {}

    Stack(const Stack<T>& s)
    {
        size_t capacity = s._capacity;
        _pData = new T[capacity];
        size_t size = s._size;

        for(size_t idx=0; idx<size; ++idx)
        {
            _pData[idx] = s._pData[idx];
        }
        _size = size;
        _capacity = capacity;
    }

    Stack<T>& operator=(const Stack<T>& s)
    {
        if(this != &s)
        {
            size_t capacity = s._capacity;
            size_t size = s._size;
            if(_capacity < size)
            {
                _pData = new T[capacity];
                for(size_t idx=0; idx<size; ++idx)
                {
                    _pData[idx] = s._pData[idx];
                }
                _size = size;
                _capacity = capacity;
            }
        }
        return *this;
    }

    void Push(const T& data)
    {
        CheckCapacity();
        if(_size == 0)
            _pData[0] = data;
        else
        {
            _pData[_size-1] = data;
        }
        _size++;
    }

    void Pop()
    {
        assert(!Empty());
        --_size;
    }

    bool Empty()const
    {
        if(_size == 0)
            return true;
        return false;
    }

    T& Top()
    {
        return _pData[_size-1];
    }

    size_t Size()const
    {
        return _size;
    }

    ~Stack()
    {
        if(_pData != NULL)
        {
            delete _pData;
            _pData = NULL;
            _size = 0;
            _capacity = 0;
            cout<<this<<endl;

        }
    }

private:
    void CheckCapacity()
    {
        // 申请新空间
        // 拷贝元素到新空间
        //memcpy() 优点：快  缺点：浅拷贝
        //for()  优点：避免了浅拷贝  缺点：速度慢
        // 类型萃取
        // 释放旧空间

        if(_size >= _capacity)
        {
            size_t capacity = _capacity + 3;
            T* pTemp = new T[capacity];
            Copy(pTemp, _pData, sizeof(T)*Size());
            delete[] _pData;
            _pData = pTemp;
            _capacity = capacity;
        }

    }

private:
    T* _pData;
    size_t _size;
    size_t _capacity;
};

void FunTest()
{
    Stack<int> s1;

    Stack<double> s3;
    Stack<int> s4;

    s1.Push(1);
    s1.Push(2);
    s1.Push(3);
    s1.Push(4);
    s1.Push(5);

    s1.Pop();
    s1.Pop();
    s1.Top();
    Stack<int> s2(s1);
    s4 = s1;


    s3.Push('1.0f');
    s3.Push('2.0f');
    s3.Push('3.0f');
    s3.Push('4.0f');
    s3.Push('5.0f');

    s3.Pop();
    s3.Pop();
    s3.Top();
}

int main()
{
    FunTest();

    system("pause");
    return 0;
}