C ++实现顺序栈

小鱼儿 2022-12-30 13:56 98阅读 0赞

版本一：  
int类型，只有构造函数和析构函数

class sstack{ 
    public:
        sstack(int cap=10):_cap(cap){ //开辟空间
            _p=new int[cap]();
            _size=0;
        }
        ~sstack(){ 
            delete[] _p;
            _p=NULL;//指针要等于nullptr
            _size=_cap=0;
        }
        void push(int x){ 
            if(_size==_cap){ //如果没有空间
                this->resize();
            }
            _p[_size++]=x;
        }
        int pop(){ 
            if(_size==0){ return -1;}
            return _p[--_size];
        }
        int top(){ 
            if(_size==0){ return -1;}
            return _p[_size-1];       
        }
        bool empty(){ return _size==0;}
        int size(){ return _size;}
        
    private:
        int *_p;
        int _size;
        int _cap;
        void resize(){ 
            int *p1=new int[_cap*2]();
            for(int i=0;i<_size;i++){ 
                p1[i]=_p[i];
            }
            delete[]_p;
            _p=p1;
            _cap*=2;        
        }
    };
    int mian(){ 
    	sstack s;//定义时间：先开辟内存，然后调用构造函数。
    
    }

版本二：拷贝构造函数+拷贝赋值构造函数

class sstack{ 
    public:
        sstack(int cap=10):_cap(cap){ //开辟空间
            _p=new int[cap]();
            cout<<"ok"<<endl;
            _size=0;
        }
        ~sstack(){ 
            delete[] _p;
            _p=NULL;//指针要等于nullptr
            _size=_cap=0;
        }
        //拷贝构造和拷贝赋值
        sstack(const sstack &ss){ //阻止浅拷贝的就要，复制资源，让 新指针指向复制的资源
            cout<<"statck"<<endl;
            //防止浅拷贝。
            _p=new int[ss._cap];
            _cap=ss._cap;
            _size=ss._size;
            for(int i=0;i<_size;i++){ 
                _p[i]=ss._p[i];
            }
        }
        sstack& operator=(const sstack&ss){ //赋值操作，返回值是引用。
            cout<<"===="<<endl;
            if(this==&ss){ 
                return *this;
            }
            delete[] _p;
    
             _p=new int[ss._cap];
            _cap=ss._cap;
            _size=ss._size;
            for(int i=0;i<_size;i++){ 
                _p[i]=ss._p[i];
            }
            return *this;//拷贝赋值运算符返回的时候，return的时候，会return *this 。
        }
    
        void push(int x){ 
            if(_size==_cap){ //如果没有空间
                this->resize();
            }
            _p[_size++]=x;
        }
        int pop(){ 
            if(_size==0){ return -1;}
            return _p[--_size];
        }
        int top(){ 
            if(_size==0){ return -1;}
            return _p[_size-1];       
        }
        bool empty(){ return _size==0;}
        int size(){ return _size;}
        
    private:
        int *_p;
        int _size;
        int _cap;
        void resize(){ 
            int *p1=new int[_cap*2]();
            for(int i=0;i<_size;i++){ 
                p1[i]=_p[i];
            }
            delete[]_p;
            _p=p1;
            _cap*=2;        
        }
    };

1.29练习

#include<bits/stdc++.h>
    using namespace std;
    class sstack{ 
    public:
        sstack(int cap=10):_cap(cap),_siz(0){ 
            _p=new int[_cap];
        }
        ~sstack(){ 
            delete[]_p;
        }
        sstack(const sstack&rhs){ 
            _siz=rhs._siz;
            _cap=rhs._cap;
            _p=new int[_cap];
            for(int i=0;i<_siz;i++){ 
                _p[i]=rhs._p[i];
            }
        }
        sstack& operator=(const sstack&rhs){ //判断自赋值、分配新空间，拷贝
            if(&rhs==this)return *this;
    
            delete[] _p;
    
            _siz=rhs._siz;
            _cap=rhs._cap;
            _p=new int[_cap];
            for(int i=0;i<_siz;i++){ 
                _p[i]=rhs._p[i];
            }
            return *this;
        }
        int top(){ 
            if(_siz>0)return _p[_siz-1];
            return -1;
        }
        int push(int x){ 
            if(_siz==_cap){ 
                resize();
            }
            _p[_siz++]=x;
        }
        int pop(){ 
            _siz--;
        }
        int size(){ return _siz-1;}
    private:
        int _cap;
        int _siz;
        int* _p;
        void resize(){ 
            _cap*=2;
            int* p =new int[_cap];
            for(int i=0;i<_siz;i++){ 
                p[i]=_p[i];
            }
            delete[]_p;
            _p=p;
        }
    };
    
    int main(){ 
        sstack data;
        for(int i=0;i<=10;i++)
        data.push(i);
        cout<<data.top()<<endl;
        cout<<data.size()<<endl;
        data.pop();
        cout<<data.top()<<endl;
        cout<<data.size()<<endl;
    
    
        return 0;
    }