C ++实现顺序栈

版本一：
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;
}