C++中类，构造函数，析构函数、拷贝构造函数

【c++】自行封装一个栈的类，包含私有成员属性：栈的数组、记录栈顶的变量，要求成员函数完成：构造函数、析构函数、拷贝构造函数、入栈、出栈、清空栈、判空、判满、获取栈顶元素、求栈的大小

#include <iostream>

using namespace std;

class Stack
{
private:
    int *datatype;
    int size;                 //栈的大小
    int top;                 //记录栈顶元素的下标

public:
    //显性定义析构函数
    Stack(int Stacksize)
    {
        size=Stacksize;
        datatype=new int[size];
        top=-1;
    }
    //拷贝构造函数
    Stack(const Stack& other)
    {
        size=other.size;
        top=other.top;
        datatype=new int [size];
        //复制数据
        for(int i=0;i<=top;i++)
        {
            datatype[i]=other.datatype[i];
        }

    }
    //判空
    bool stack_empty()
    {
        return this->top==-1;

    }

    //判满
    bool stack_full()
    {
        return this->top==this->size-1;
    }


    //入栈
    int stack_push(int element)
    {
        if(!stack_full())
        {
            top++;
            datatype[top]=element;
            cout<<"入栈成功:"<<element<<endl;
            return 0;
        }
        cout<<"入栈失败"<<endl;
        return -1;
    }

    //遍历栈
    void stack_show()
    {
        cout<<"从栈顶到栈低的元素为：";
        for(int i=top;i>=0;i--)
        {cout<<datatype[i]<<"  ";

        }
        cout<<endl;
    }

    //出栈
    void stack_pop()
    {
        cout<<"出栈成功"<<datatype[top]<<endl;
        top--;
    }

    //获取栈顶元素
    void stack_top()
    {
        if(stack_empty()&&top>size)
        {
            cout<<"获取栈顶元素失败"<<endl;
        }
        cout<<"栈顶元素为："<<datatype[top]<<endl;
    }

    //求栈的大小
    int stack_size()
    {if(!stack_empty())
        {
        return top+1;
         }
        return -1;
    }
    //清空栈
    void stack_clear()
    {
        while(!stack_empty())
        {
            stack_pop();
        }
    }
    ~Stack()
    {
        delete []datatype;
    }

};
int main()
{
    Stack stack(5);
    //入栈
    stack.stack_push(1);
    stack.stack_push(2);
    stack.stack_push(3);
    stack.stack_push(4);
    stack.stack_push(5);

    //show
    stack.stack_show();
    //求栈顶元素为
    stack.stack_top();
    //栈的大小
    cout<<"栈的大小为："<<stack.stack_size()<<endl;
    //弹栈
    stack.stack_pop();
    //清空栈
    stack.stack_clear();
    //show
    stack.stack_show();

    return 0;
}

 效果图：

【c++】自行封装一个循环顺序队列的类，包含私有成员属性：存放队列的数组、队头位置、队尾位置，成员函数完成：构造函数、析构函数、拷贝构造函数、入队、出队、清空队列、判空、判满、求队列大小

#include <iostream>

using namespace std;

class Queue
{
    int size;
    int *datatype;   //存储队列的数组容器
    int front;                  //记录对头所在元素的下标
    int tail;    //记录最后一个元素的下一个位置的下标//队的大小

public:
    //显性定义无参析构函数
    Queue(int size)
    {
        datatype=new int[size];
        front=0;
        tail=0;
        this->size=size;
    }
    //拷贝构造函数
    Queue(const Queue &other)
    {
        size=other.size;
        front=other.front;
        front=other.front;
        datatype=new int [size];
        //复制数据
        for(int i=front;i<tail;i++)
        {
            datatype[front]=other.datatype[front];
        }
    }
    //判空
    bool queue_empty()
    {
        return front==tail;
    }

    //判满
    bool queue_full()
    {
        return (tail+1)%size==front;
    }

    //入队
    int queue_push(int element)
    {
        if(!queue_full())
        {
            datatype[tail]=element;
            tail=(tail+1)%size;
            cout<<element<<" : 入队成功"<<endl;
            return 0;

        }


        cout<<"入队失败"<<endl;
        return -1;
    }


    //出队
    int queue_pop()
    {
        if(queue_empty())
        {
            cout<<"出队失败"<<endl;
            return -1;
        }
        cout<<datatype[front]<<" : 出队成功"<<endl;
        front=(front+1)%size;
        return 0;
    }

    //求队的大小
    int queue_size()
    {
        return (tail-front+size)%size;
    }

    //清空队
    void queue_clear()
    {
        while(!queue_empty())
        {
        queue_pop();
        }
    }
    ~Queue()
    {
        delete []datatype;
    }

};
int main()
{
    Queue q(5);
    //入队
    q.queue_push(0);
    q.queue_push(1);
    q.queue_push(2);
    q.queue_push(3);
    q.queue_push(4);

    //出队
    q.queue_pop();
    cout<<"队的大小"<<q.queue_size()<<endl;
    //清空队
    q.queue_clear();
    cout<<"队的大小"<<q.queue_size()<<endl;

    return 0;
}

 效果图：

 C++的思维导图