C++&QT day3

1> 自行封装一个栈的类，包含私有成员属性：栈的数组、记录栈顶的变量

成员函数完成：构造函数、析构函数、拷贝构造函数、入栈、出栈、清空栈、判空、判满、获取栈顶元素、求栈的大小

2> 自行封装一个循环顺序队列的类，包含私有成员属性：存放队列的数组、队头位置、队尾位置

成员函数完成：构造函数、析构函数、拷贝构造函数、入队、出队、清空队列、判空、判满、求队列大小

1：

#include 
#define MAX 128
 
using namespace std;
class Stack_s
{
private:
    int *p=new int[MAX];//栈的数组
    int top;//记录栈顶的变量
public:
    //构造函数
    Stack_s(int t=-1)
    {
        top=t;
        cout<<"无参构造函数"<
    }
    //析构函数
    ~Stack_s()
    {
        cout<<"Stack::析构函数"<
    }
    //拷贝构造函数
    Stack_s(const Stack_s &other):p(other.p),top(other.top)
    {
        cout<<"拷贝构造函数"<
    }
    //入栈
    int stack_push(int e)
    {
        if(stack_full())
        {
            cout<<"入栈失败"<
            return -1;
        }
        top++;
        p[top]=e;
        cout<<"入栈成功"<
        return 0;
    }
    //出栈
    int stack_pop()
    {
        if(stack_empty())
        {
            cout<<"出栈失败"<
            return -1;
        }
        int e=p[top];
        top--;
        cout<" 出栈成功"<
        return 0;
    }
    //清空栈
    int stack_delete()
    {
        while(top!=-1)
        {
            stack_pop();
        }
        delete [] p;
        p=nullptr;
        cout<<"清空栈成功"<
        return 0;
    }
    //判空
    bool stack_empty()
    {
        if(top==-1)
        {
            cout<<"栈空"<
            return 1;
        }
        return 0;
    }
    //判满
    bool stack_full()
    {
        if(top==MAX-1)
        {
            cout<<"栈满了"<
            return 1;
        }
        return 0;
        return 0;
    }
    //获取栈顶元素
    int stack_gettop()
    {
        cout<<"栈顶元素是："<
        return 0;
    }
    //栈的大小
    void stack_getsize()
    {
        cout<<"栈的大小为："<1<
    }
    void show(int i)
    {
        cout<" ";
    }
};
int main()
{
    Stack_s s1;
    int e;
    int s;
    s1.stack_empty();
    cout<<"请输入要入栈的个数：";
    cin>>s;
    for(int i=0;i
    {
        cout<<"请输入要入栈的元素：";
        cin>>e;
        s1.stack_push(e);
    }
    s1.stack_gettop();
     s1.stack_getsize();
    for(int i=0;i
    {
        s1.show(i);
    }
    cout<
    s1.stack_delete();
    return 0;
}

2：

#include 
#define MAX 128
 
using namespace std;
class Queue_q
{
private:
    int *p=new int[MAX];//队列的数组
    int tail;//记录队尾元素
    int head;//记录对头元素
public:
    //构造函数
    Queue_q(int t=0)
    {
        head=t;
        tail=t;
        cout<<"无参构造函数"<
    }
    //析构函数
    ~Queue_q()
    {
        cout<<"Stack::析构函数"<
    }
    //拷贝构造函数
    Queue_q(const Queue_q &other):p(other.p),tail(other.tail),head(other.head)
    {
        cout<<"拷贝构造函数"<
    }
    //入队
    int queue_push(int e)
    {
        if(queue_full())
        {
            cout<<"入队失败"<
            return -1;
        }
        p[tail]=e;
        tail++;
        cout<<"入队成功"<
        return 0;
    }
    //出队
    int queue_pop()
    {
        if(queue_empty())
        {
            cout<<"出队失败"<
            return -1;
        }
        int e=p[head];
        head=(head+1)%MAX;
        cout<" 出队成功"<
        return 0;
    }
    //清空队列
    int queue_delete()
    {
        while(head!=tail)
        {
            queue_pop();
        }
        delete [] p;
        p=nullptr;
        cout<<"清空队列成功"<
        return 0;
    }
    //判空
    bool queue_empty()
    {
        if(head==tail)
        {
            cout<<"队列空"<
            return 1;
        }
        return 0;
    }
    //判满
    bool queue_full()
    {
        if((tail+1)==0)
        {
            cout<<"队列满了"<
            return 1;
        }
        return 0;
    }
    //队列的大小
    void queue_getsize()
    {
        int size;
        size=(tail-head+MAX)%MAX;
        cout<<"队的大小为："<
    }
    void show(int i)
    {
        cout<" ";
    }
};
int main()
{
    Queue_q q1;
    int e;
    int s;
    q1.queue_empty();
    cout<<"请输入要入队的个数：";
    cin>>s;
    for(int i=0;i
    {
        cout<<"请输入要入队的元素：";
        cin>>e;
        q1.queue_push(e);
    }
     q1.queue_getsize();
    for(int i=0;i
    {
        q1.show(i);
    }
    cout<
    q1.queue_delete();
    return 0;
}

思维导图：