栈的基本操作

来源：互联网发布：mysql 断电无法启动编辑：程序博客网时间：2024/05/18 19:18
#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;}
0 0