构造函数和析构函数

oop实现顺序栈

class SeqStack{
    public :
        void init(int size=10)  //形参默认值
        {
            _pstack = new int[size];   
            _top = -1;
            _size = size;
        }
        void release()
        {
            delete [] _pstack;  //delete[]
            _pstack = nullptr;
        }
        void push(int val)
        {
            if(full())
             resize();
            _pstack[++_top] = val;
        }
        void pop()
        {
            if(empty())
             return;
            --_top;

        }
        int top()
        {
            return _pstack[_top];
        }
        bool empty()
        {
            return _top == -1;
        }
        bool full()
        {
            return _top == _size - 1;
        }



    private : //先看属性，写成私有
        int *_pstack;  //指针，写成指针内存可增长
        int _top;       //栈顶
        int _size;
        void resize()   //扩容
        {
            int *ptmp = new int[_size * 2];
            for(int i = 0; i <= _top; ++i)
            {
                ptmp[i] = _pstack[i];
            }   //memcpy（ptmp,_pstack,_size*sizeof(int)）
            //realloc  此处int内存拷贝可以，但对象时不合适
            delete [] _pstack;
            _pstack = ptmp;
            size *= 2;
        }


};

int main(){
    SeqStack s;
    s.init();
    for(int i = 0; i < 15; ++i)
    {
        s.push(rand()%100);
    }
    while(!s.empty())
    {
        cout << s.top() << " ";
        s.pop();
    }
    s.release();
}

构造函数和析构函数

函数的名字和类名一样，无返回值

class SeqStack{
    public :
    //构造函数可带参数，可以有多个重载
        SeqStack(int size=10)  //不用init了
        {
            cout<<this<<"SeqStack()"<<endl;
            _pstack = new int[size];  
            _top = -1;
            _size = size;
        }
        ~SeqStack()  //析构函数，只能有一个，不带参数
        {
            cout<<this<<"~SeqStack()"<<endl;
            delete [] _pstack; 
            _pstack = nullptr;
        }
        void push(int val)
        {
            if(full())
             resize();
            _pstack[++_top] = val;
        }
        void pop()
        {
            if(empty())
             return;
            --_top;

        }
        int top()
        {
            return _pstack[_top];
        }
        bool empty()
        {
            return _top == -1;
        }
        bool full()
        {
            return _top == _size - 1;
        }



    private : //先看属性，写成私有
        int *_pstack;  //指针，写成指针内存可增长
        int _top;       //栈顶
        int _size;
        void resize()   //扩容
        {
            int *ptmp = new int[_size * 2];
            for(int i = 0; i <= _top; ++i)
            {
                ptmp[i] = _pstack[i];
            }   //memcpy（ptmp,_pstack,_size*sizeof(int)）
            //realloc  此处int内存拷贝可以，但对象时不合适
            delete [] _pstack;
            _pstack = ptmp;
            size *= 2;
        }


};
SeqStack gs;    //全局变量，最后析构
int main(){

    SeqStack *ps = new SeqStack(60);
    //这种不会自己析构
    //new=分配内存+构造函数

    delete ps;  //delete=析构+free





    //定义一个对象，1.开辟内存 2.调用构造函数
    SeqStack s;
    //s.init();
    for(int i = 0; i < 15; ++i)
    {
        s.push(rand()%100);
    }
    while(!s.empty())
    {
        cout << s.top() << " ";
        s.pop();
    }

    SeqStack s1(50);    //先构造后析构
    return 0; //析构函数会自动调用

}