Cpp/Qtday030908cpp基础

目录

目录

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

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

头文件：stack.h

源文件:  stack.cpp

测试文件：main.cpp

效果图

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

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

头文件：queue.h

源文件:  queue.cpp

测试文件：main.cpp

效果图

思维导图

---

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

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

头文件：stack.h

#ifndef STACK_H
#define STACK_H
#include <iostream>

using namespace std;

class Stack
{
private:
    int data[128];
    int top;
public:
    Stack();
    ~Stack();
    Stack(Stack &s);
    //判空
    bool stack_empty();
    //返回布尔类型，真为空，假为非空
    //判满
    bool stack_full();
    //返回布尔类型，真为满，假为非满
    //入栈
    int stack_in(int num);
    //出栈
    int stack_out();
    //清空栈
    bool stack_clear();
    //获取栈顶元素
    int stack_get_top();
    //求栈的大小
    int stack_size();
    //为了便于观察现象，加一个展示栈内元素的函数，从栈顶向栈底
    void stack_show();
};

#endif // STACK_H

源文件:  stack.cpp

#include "stack.h"

Stack::Stack():top(-1){
    cout<<"Stack:构造函数"<<endl;
}

Stack::~Stack(){
    cout<<"Stack:析构函数"<<endl;
}

Stack::Stack(Stack &s):top(s.top){
    for(int i=0; i<=top; i++){
        data[i] = s.data[i];
    }
    cout<<"Stack:拷贝构造函数"<<endl;
}
//判空
bool Stack::stack_empty(){
    //top正好记录栈顶元素的下标，所以当top为-1时，栈空
    return -1 == top;
}
//判满
bool Stack::stack_full(){
    //top正好记录栈顶元素的下标，所以当top为127时，栈满
    return 127 == top;
}
//入栈
int Stack::stack_in(int num){
    //如果栈满，则拒绝入栈
    if(Stack::stack_full()){
        cout<<"栈已满"<<endl;
        return -1;
    }
    //将栈顶变量的值+1，就能指向新的栈顶
    top++;
    //将要入栈的数据放入数组中
    data[top] = num;
    return 0;
}
//出栈
int Stack::stack_out(){
    //判断栈是否为空，为空则无法出栈
    if(Stack::stack_empty()){
        cout<<"栈已空"<<endl;
        return -1;
    }
    //按照我的定义，top正好记录了栈顶元素的下标,因此top--，会将top自减，并且top--这个表达式
    //的值为top，所以可以输出data[top]也就是栈顶元素的值，同时top自减一次，而要出栈，出的
    //就是栈顶元素
    return data[top--];
}
//清空栈
bool Stack::stack_clear(){
    //如果栈本身为空则无需清空
    if(Stack::stack_empty()){
        cout<<"栈已空"<<endl;
        return false;
    }
    //如果栈非空则需要清空

    //将栈顶指针置为-1即可
    top = -1;
    return true;
}
//获取栈顶元素
int Stack::stack_get_top(){
    //首先栈要非空
    if(Stack::stack_empty()){
        cout<<"栈已空"<<endl;
        return -1;
    }
    //原理与出栈相同，唯一的区别就是无需将栈顶变量移动
    return data[top];
}
//求栈的大小
int Stack::stack_size(){
    //已知，top变量记录了栈顶元素的下标，所以要求栈中的元素数量，只需将top+1就可得到
    return top+1;
}
//为了便于观察现象，加一个展示栈内元素的函数，从栈顶向栈底
void Stack::stack_show(){
    //首先栈要非空
    if(Stack::stack_empty()){
        cout<<"栈为空"<<endl;
        return ;
    }
    for(int i=top; i>-1; i--){
        cout << data[i] << "  ";
    }
    cout<<endl;
}

测试文件：main.cpp

#include <iostream>
#include "stack.h"

using namespace std;

int main()
{
    Stack s1;
    //入栈
    s1.stack_in(4);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(3);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(9);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(6);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(1);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(5);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(5);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    s1.stack_in(7);
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    //拷贝构造函数的使用
    Stack s2(s1);
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    //出栈
    cout<<s1.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    cout<<s1.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    cout<<s1.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    //获取栈的大小
    cout<<"此时栈内元素的数量为:"<<s1.stack_size()<<endl;
    //栈顶元素为
    cout<<"栈顶元素为:"<<s1.stack_get_top()<<endl;
    //清空栈
    s1.stack_clear();
    cout<<"栈清空成功"<<endl;
    //展示栈内元素
    cout<<"s1:";
    s1.stack_show();
    return 0;
}

效果图

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

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

头文件：queue.h

#ifndef QUEUE_H
#define QUEUE_H

#include <iostream>

using namespace std;

class Queue
{
private:
    int data[12];
    int head;
    int tail;

public:
    //构造函数
    Queue();
    //析构函数
    ~Queue();
    //拷贝构造函数
    Queue(Queue &q);
    //判空
    bool queue_empty();
    //判满
    bool queue_full();
    //入队
    int queue_in(int num);
    //出队
    int queue_out();
    //清空队列
    bool queue_clear();
    //求队列大小
    int queue_size();
    //为了便于观察现象，加一个展示队列元素的函数，从队头到队尾
    void queue_show();
};

#endif // QUEUE_H

源文件:  queue.cpp

#include "queue.h"

//构造函数
Queue::Queue():head(0),tail(0){
    cout<<"Queue:构造函数"<<endl;
}

//析构函数
Queue::~Queue(){
    cout<<"Queue:析构函数"<<endl;
}

//拷贝构造函数
Queue::Queue(Queue &q):head(q.head),tail(q.tail){
    int h = head;
    while(h!=tail){
        data[h] = q.data[h];
        h = (h+1)%12;
    }
    cout<<"Queue:拷贝构造函数"<<endl;
}

//判空
bool Queue::queue_empty(){
    //当队列的头变量与尾变量的值相同时，队列为空
    return head == tail;
}

//判满
bool Queue::queue_full(){
    //队尾变量记录的下标中是不保存变量的，以便操作与计数
    //因此，当队尾变量的值比对头变量的值小1或者-11的时候，队满
    return (tail+1)%12 == head;
}

//入队
int Queue::queue_in(int num){
    //要能入队，首先队列不能为满
    if(Queue::queue_full()){
        cout<<"队列已满，无法入队"<<endl;
        return -1;
    }

    //此时可以入队
    data[tail] = num;

    //队尾变量自增一次
    tail = (tail + 1)%12;

    return 0;
}

//出队
int Queue::queue_out(){
    //要能出队，首先队列不能为空
    if(Queue::queue_empty()){
        cout<<"队列已空，无法入队"<<endl;
        return -1;
    }
    //此时可以出队
    int tmp = data[head];
    //对头变量自增一次
    head = (head + 1)%12;

    return tmp;
}

//清空队列
bool Queue::queue_clear(){
    //若队列为空则无需清空
    if(Queue::queue_empty()){
        cout<<"队列已空，无需清空"<<endl;
        return false;
    }
    //操作队头队尾变量，使满足队列为空的条件
    head = tail;

    return true;
}

//求队列大小
int Queue::queue_size(){
    //根据队首队尾的位置即可求出队列大小
    return (tail + 12 - head)%12;
}

//为了便于观察现象，加一个展示队列元素的函数，从队头到队尾
void Queue::queue_show(){
    //若队列为空则提示队列为空
    if(Queue::queue_empty()){
        cout<<"队列为空"<<endl;
        return;
    }
    int h = head;
    while(h!=tail){
        cout<<data[h]<<"  ";
        h = (h+1)%12;
    }
    cout<<endl;
    return;
}

测试文件：main.cpp

#include <iostream>
#include "queue.h"
using namespace std;

int main()
{
    Queue q1;
    //入队
    q1.queue_in(4);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(3);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(9);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(6);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(1);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(5);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(5);
    //展示
    cout<<"q1: ";
    q1.queue_show();
    //入队
    q1.queue_in(7);
    //展示
    cout<<"q1: ";
    q1.queue_show();

    //拷贝构造函数
    Queue q2(q1);
    //展示
    cout<<"q2: ";
    q2.queue_show();

    //出队
    cout<<q1.queue_out()<<"出队成功"<<endl;
    //出队
    cout<<q1.queue_out()<<"出队成功"<<endl;
    //出队
    cout<<q1.queue_out()<<"出队成功"<<endl;
    //展示
    cout<<"q1: ";
    q1.queue_show();

    //求队列大小
    cout<<"q1队列大小为"<<q1.queue_size()<<endl;

    //清空队列
    q1.queue_clear();
    cout<<"队列清空成功"<<endl;

    //展示
    cout<<"q1: ";
    q1.queue_show();

    //求队列大小
    cout<<"q1队列大小为"<<q1.queue_size()<<endl;


    return 0;
}

效果图

思维导图