2023/09/08 qt&c++ day3

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

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

头文件

#ifndef STACK_H
#define STACK_H
#include <iostream>
using namespace std;
class st
{
private:
    //记录栈顶的变量
    int top;
    //使用指针来存储栈
    int *data;

public:
    //构造函数
    st():top(-1),data(new int[5])
    {
        cout<<"无参构造函数"<<endl;
    }
    //析构函数
    ~st()
    {
        delete []data; //释放成员指针的空间
        cout<<"析构函数:"<<endl;
    }
    //拷贝构造函数
    st(const st &other):data(new int(*other.data))
    {
        cout<<"拷贝构造函数:"<<endl;
    }
    //入栈
    int stack_in(int e,int *data);
    //遍历栈
    void stack_show(int *data);
    //出栈
    int stack_out(int *data);
    //清空栈
    void stack_clear(int *data);
    //判空
    int stack_empty(int *data);
    //判满
    int stack_full(int *data);
    //获取栈顶元素
    int *stack_top(int *data);
    //求栈的大小
    int stack_size(int *data);

};
#endif // STACK_H

功能函数

#include "stack.h"

//入栈
int st::stack_in(int e,int *data)
{
    if(nullptr == data||stack_full(data))
    {
        cout<<"入栈失败!"<<endl;
        return -1;
    }
    //先加后压
    top++;
    data[top] =e; //将数据存放到栈中
    cout<<"入栈成功"<<endl;
    return 1;
}
//遍历栈

void st::stack_show(int *data)
{
    if(nullptr == data||stack_empty(data))
    {
        cout<<"遍历失败!"<<endl;
        return ;
    }
    //开始遍历
    cout<<"从栈顶到栈底的元素是:";
    for(int i=top;i>=0;i--)
    {
        cout<<"  "<<data[i];
    }
    return ;
}
//出栈
int st::stack_out(int *data)
{
    if(nullptr ==data||stack_empty(data))
    {
        cout<<"出栈失败!"<<endl;
        return -1;
    }
    //先弹后减
    int e = data[top];
    top--;
    cout<<"出栈成功!"<<endl;
    return 0;
}
//清空栈
void st::stack_clear(int *data)
{
    //判断逻辑
    if(nullptr==data)
    {
        cout<<"清空失败!"<<endl;
        return ;
    }
    delete []data;
    data =nullptr;
    return;
}
//判空
int st::stack_empty(int *data)
{
    if(nullptr != data)
    {
        return top == -1;
    }
    cout<<"栈不合法!"<<endl;

    return 0;
}
//判满
int st::stack_full(int *data)
{
    if(nullptr != data)
    {
        return top == sizeof(int[5])-1;
    }
    cout<<"栈不合法!"<<endl;
    return 0;
}
//获取栈顶元素
int *st::stack_top(int *data)
{
    if(nullptr == data||stack_empty(data))
    {
        cout<<"获取失败!"<<endl;
        return nullptr;
    }
    cout<<"栈顶元素是:"<<data[top]<<endl;
    return &data[top];
}
//求栈的大小
int st::stack_size(int *data)
{
    if(nullptr != data)
    {
        cout<<"栈的大小是:"<<top+1<<endl;
        return top+1;
    }
    cout<<"不合法!"<<endl;
    return 0;
}

主函数

#include "stack.h"
int main()
{
    st s1;
    int stack[5];
    //入栈
    s1.stack_in(3,stack);
    s1.stack_show(stack);
    s1.stack_top(stack);
    s1.stack_size(stack);
    s1.stack_in(4,stack);
    s1.stack_show(stack);
    s1.stack_top(stack);
    s1.stack_size(stack);
    s1.stack_in(5,stack);
    s1.stack_show(stack);
    s1.stack_top(stack);
    s1.stack_size(stack);
    s1.stack_in(6,stack);
    s1.stack_show(stack);
    s1.stack_top(stack);
    s1.stack_size(stack);
    s1.stack_in(7,stack);
    s1.stack_in(7,stack);
    s1.stack_in(7,stack);
    s1.stack_in(7,stack);
    //遍历栈
    s1.stack_show(stack);
    //出栈
    s1.stack_out(stack);
    s1.stack_out(stack);
    s1.stack_out(stack);
    s1.stack_out(stack);
    s1.stack_out(stack);
    s1.stack_out(stack);
     //遍历栈
    s1.stack_show(stack);
    //获取栈顶元素
    s1.stack_show(stack);
    s1.stack_top(stack);
    s1.stack_size(stack);

      //求栈的大小
     //清空栈
    s1.stack_clear(stack);
    return 0;
}

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

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

头文件

#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
using namespace std;
class queue
{
private:
    //存放队列的数组
    int *data;
    //队头位置下标
    int head;
    //队尾位置下标
    int tail;
public:
    //构造函数
    queue():data(new int[5]),head(tail=0),tail(head=0)
    {
        cout<<"无参构造函数"<<endl;
    }
    //析构函数
    ~queue()
    {
        delete []data;
        cout<<"析构函数"<<endl;

    }
    //拷贝构造函数
    queue(const queue &other):head(other.head),tail(other.tail),data(new int(*other.data))
    {
        cout<<"拷贝构造函数"<<endl;
    }
    //判空
    int queue_empty(int *data);
    //判满
    int queue_full(int *data);
    //入队
    int queue_in(int e,int *data);
    //遍历
    void queue_show(int *data);
    //出队
    int queue_out(int *data);
    //求队列大小
    int queue_size(int *data);
    //清空队列
    void queue_clear(int *data);

};
#endif // QUEUE_H

功能函数

#include "queue.h"
//判空
int queue::queue_empty(int *data)
{
    if(nullptr == data)
    {
        cout<<"不合法!"<<endl;
        return -1;
    }
    return head == tail;
}
//判满
int queue::queue_full(int *data)
{
    if(nullptr == data)
    {
        cout<<"不合法!"<<endl;
        return -1;
    }
    return (tail+1)%20 == head;
}
//入队

int queue::queue_in(int e,int *data)
{
    //判断逻辑
    if(nullptr==data||queue_full(data))
    {
        cout<<"队列已经满了，无法入队!"<<endl;
        return -1;
    }
    //入队逻辑,将数据放在队尾所在的地方
    data[tail] = e;
    //队尾后移
    tail = (tail+1)%20;
    cout<<"入队成功\n";
    return 0;

}
//遍历
void queue::queue_show(int *data)
{
    //判断逻辑
    if(nullptr==data||queue_empty(data))
    {
        cout<<"队列不合法"<<endl;
        return ;
    }
    for(int i=head;i!=tail;i=(i+1)%20)
    {
        cout<<data[i]<<" ";
    }
    cout<<"遍历成功!"<<endl;
}
//出队
int queue::queue_out(int *data)
{
    //判断逻辑
    if(nullptr==data||queue_empty(data))
    {
        cout<<"队列不合法"<<endl;
        return -1;
    }
    //出队逻辑
    //将队头所在的位置元素删除,先进先出
    int e = data[head];
    //队头后移
    head =(head+1)%20;
    cout<<"出队成功"<<endl;
    return 0;



}
//求队列大小
int queue::queue_size(int *data)
{
    //判断逻辑
    if(nullptr==data||queue_empty(data))
    {
        cout<<"队列不合法"<<endl;
        return -1;
    }
    return (tail-head+20)%20;

}
//清空队列
void queue::queue_clear(int *data)
{
    if(nullptr!=data)
    {
        delete [] data;
        data = nullptr;
        cout<<"释放成功!"<<endl;
        return ;
    }
    cout<<"队列不合法！"<<endl;

}

主函数

#include "queue.h"
int main()
{
    //实例化对象
    queue q1;
    int d[5];
    //入队
    q1.queue_in(1,d);
    q1.queue_in(2,d);
    q1.queue_in(3,d);
     q1.queue_show(d);


    q1.queue_in(4,d);
    q1.queue_in(10,d);
    q1.queue_in(13,d);
    q1.queue_show(d);


    q1.queue_in(16,d);
    //遍历
    q1.queue_show(d);
    //出队
    q1.queue_out(d);
     q1.queue_show(d);
    //求队列大小
    int len =q1.queue_size(d);
    cout<<"len = "<<len<<endl;

    return 0;
}