Cpp/Qtday060913cpp基础

news2025/1/20 17:05:21

目录

将栈类实现成模板类

代码

效果

将队列类实现成模板类

代码

效果

思维导图

将栈类实现成模板类
代码
#include <iostream>

using namespace std;

template<typename T>
class Stack
{
private:
    T data[128];
    int top;
public:
    Stack();
    //Stack(T unit);
    ~Stack();
    Stack(Stack &s);
    //判空
    bool stack_empty();
    //返回布尔类型，真为空，假为非空
    //判满
    bool stack_full();
    //返回布尔类型，真为满，假为非满
    //入栈
    int stack_in(T unit);
    //出栈
    T stack_out();
    //清空栈
    bool stack_clear();
    //获取栈顶元素
    T stack_get_top();
    //求栈的大小
    int stack_size();
    //为了便于观察现象，加一个展示栈内元素的函数，从栈顶向栈底
    void stack_show();
};
template<typename T>
Stack<T>::Stack():top(-1){
    cout<<"Stack:无参构造"<<endl;
}
//template<typename T>
//Stack<T>::Stack(T unit):data(unit),top(0){
//    cout<<"Stack:无参构造"<<endl;
//}
template<typename T>
Stack<T>::~Stack(){
    cout<<"Stack:析构函数"<<endl;
}
template<typename T>
Stack<T>::Stack(Stack &s):top(s.top){
    for(int i=0; i<=top; i++){
        data[i] = s.data[i];
    }
    cout<<"Stack:拷贝构造函数"<<endl;
}
//判空
template<typename T>
bool Stack<T>::stack_empty(){
    //top正好记录栈顶元素的下标，所以当top为-1时，栈空
    return -1 == top;
}
//判满
template<typename T>
bool Stack<T>::stack_full(){
    //top正好记录栈顶元素的下标，所以当top为127时，栈满
    return 127 == top;
}
//入栈
template<typename T>
int Stack<T>::stack_in(T unit){
    //如果栈满，则拒绝入栈
    if(Stack::stack_full()){
        cout<<"栈已满"<<endl;
        return -1;
    }
    //将栈顶变量的值+1，就能指向新的栈顶
    top++;
    //将要入栈的数据放入数组中
    data[top] = unit;
    return 0;
}
//出栈
template<typename T>
T Stack<T>::stack_out(){
    //判断栈是否为空，为空则无法出栈
    if(Stack::stack_empty()){
        cout<<"栈已空"<<endl;
        return -1;
    }
    //按照我的定义，top正好记录了栈顶元素的下标,因此top--，会将top自减，并且top--这个表达式
    //的值为top，所以可以输出data[top]也就是栈顶元素的值，同时top自减一次，而要出栈，出的
    //就是栈顶元素
    return data[top--];
}
//清空栈
template<typename T>
bool Stack<T>::stack_clear(){
    //如果栈本身为空则无需清空
    if(Stack::stack_empty()){
        cout<<"栈已空"<<endl;
        return false;
    }
    //如果栈非空则需要清空

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

    Stack<char> s2;
    //入栈
    s2.stack_in('H');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('e');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('l');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('l');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('o');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in(' ');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('w');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    s2.stack_in('o');
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    //出栈
    cout<<s2.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    cout<<s2.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    cout<<s2.stack_out()<<"出栈成功"<<endl;
    //展示栈内元素
    cout<<"s2:";
    s2.stack_show();
    //获取栈的大小
    cout<<"此时栈内元素的数量为:"<<s2.stack_size()<<endl;
    //栈顶元素为
    cout<<"栈顶元素为:"<<s2.stack_get_top()<<endl;
    //清空栈
    s2.stack_clear();
    cout<<"栈清空成功"<<endl;
    return 0;
}
效果

由于终端不方便一次性全部展示，因此，s1,s2的完整现象需要分两次展示

将队列类实现成模板类
代码
#include <iostream>

using namespace std;

template<typename T>
class Queue
{
private:
    T data[12];
    int head;
    int tail;

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

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

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

//拷贝构造函数
template<typename T>
Queue<T>::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;
}

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

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

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

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

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

    return 0;
}

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

    return tmp;
}

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

    return true;
}

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

//为了便于观察现象，加一个展示队列元素的函数，从队头到队尾
template<typename T>
void Queue<T>::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;
}

int main()
{
    Queue<int> 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();

    //出队
    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;


    Queue<char> q2;
    //入队
    q2.queue_in('H');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('e');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('l');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('l');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('o');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('W');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('o');
    //展示
    cout<<"q2: ";
    q2.queue_show();
    //入队
    q2.queue_in('r');
    //展示
    cout<<"q2: ";
    q2.queue_show();

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

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

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

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

    //求队列大小
    cout<<"q2队列大小为"<<q2.queue_size()<<endl;
    return 0;
}
效果

由于终端不方便一次性全部展示，因此，s1,s2的完整现象需要分两次展示

思维导图

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1007485.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

比亚迪海洋家族再添新成员，合资车企又该绷不住了

比亚迪海洋家族再添新成员，合资车企又该绷不住了

燃油搅局者比亚迪最近又又又上新车啦&#xff0c;这次带来的是海洋家族中大型插电混动轿车—海豹 DM-i。 啥叫插电混动&#xff1f;简单来说同时搭载了汽油发动机、可外接电源充电的电池和电机&#xff1b; 有电时用电驱动电机做工&#xff0c;没电时用油驱动发动机做工&#…
阅读更多...
pycharm虚拟环境安装指定python版本/ python3.8 / 从python3.9降级到3.8

pycharm虚拟环境安装指定python版本/ python3.8 / 从python3.9降级到3.8

我在网上找了一圈发现各种命令,尤其是说: virtualenv -p python3 py38 可以指定版本,我真的酸Q ! 这个命令是意思是创建一个 py38 目录,实际上用的版本还是环境变量所指向的版本. 1.下载 python 版本 要想指定版本,肯定是需要本机已经有一个版本,然后指定这个版本作为虚拟环…
阅读更多...
⑥ 在vue中引入路由

⑥ 在vue中引入路由

什么是路由&#xff1a;管理页面的跳转&#xff08;vue-router&#xff09; 官方文档 https://router.vuejs.org/zh/introduction.html第一步&#xff1a;安装路由后启动项目 npm install --save vue-router配置独立的路由文件 在src目录文件下新建一个文件夹router&#xf…
阅读更多...
C++--day6

C++--day6

将之前定义的栈类和队列类都实现成模板类 栈&#xff1a; #include <iostream>using namespace std; template<typename T> class zn { private:T *num;int top;int size; public: //有参构造函数 zn(int a):top(-1),size(a){numnew T[size]; } //析构函数 ~zn()…
阅读更多...
通过 DevOps、CI/CD 和容器增强您的软件开发之旅...

通过 DevOps、CI/CD 和容器增强您的软件开发之旅...

软件行业已经在 DevOps、CI/CD 和容器中找到了针对开发导向问题的有效解决方案。尽管并不强制要求将这三者一起使用&#xff0c;但它们通常是相互补充和依赖的。 DevOps 促进开发和 IT 团队之间的协作&#xff0c;而 CI/CD 简化软件交付流程以更快地获得结果。容器化将应用程序…
阅读更多...
智安新闻｜智安网络亮相2023网安周！

智安新闻｜智安网络亮相2023网安周！

一年一度的国家网络安全“顶级盛事”——2023年国家网络安全宣传周9月拉开帷幕&#xff0c;本次展览会以“网络安全为人民&#xff0c;网络安全靠人民”为主题&#xff0c;旨在通过展览及现场互动广泛宣传网络安全知识与技能&#xff0c;提升全民网络安全意识&#xff0c;共同构…
阅读更多...
前端之webpck的优化

前端之webpck的优化

一、webpack的打包流程/webpack的机制/原理/webpack是怎么打包的 1 webpack是根据运行的指令来决定一个基本的业务流程 2 如果是build 就是执行打包&#xff0c;如果是 配合了devServer就是就行本地化的调试。 两者其实在本质上没有太大区别&#xff0c;只是devServer会运行一…
阅读更多...
Timestone: Netflix的高吞吐、低延迟优先级队列系统

Timestone: Netflix的高吞吐、低延迟优先级队列系统

队列系统是微服务系统的核心组件之一&#xff0c;本文介绍了Netflix内部构建的高吞吐量、低优先级队列系统。原文: Timestone: Netflix’s High-Throughput, Low-Latency Priority Queueing System with Built-in Support for Non-Parallelizable Workloads 简介 Timestone是Ne…
阅读更多...
【深度学习-注意力机制attention 在seq2seq中应用】

【深度学习-注意力机制attention 在seq2seq中应用】

注意力机制 为什么需要注意力机制attention机制的架构总体设计一、attention本身实现评分函数 attention在网络模型的应用-Bahdanau 注意力加性注意力代码实现 为什么需要注意力机制 这是一个普通的seq2seq结构&#xff0c;用以实现机器对话&#xff0c;Encoder需要把一个输入的…
阅读更多...
损失函数loss和优化器optimizer

损失函数loss和优化器optimizer

损失函数与优化器的关联_criterion(outputs, labels)_写代码_不错哦的博客-CSDN博客https://blog.csdn.net/shenjianhua005/article/details/123971915?ops_request_misc&request_id6583569ecbdc4daf89dbf2d43eac9242&biz_id&utm_mediumdistribute.pc_search_resu…
阅读更多...
2023常用的原型设计软件推荐

2023常用的原型设计软件推荐

美观易操作的产品原型可以帮助团队构建积极的用户体验&#xff0c;帮助团队理解产品交互逻辑。 因此&#xff0c;可互动、易修改的产品原型设计对产品的点击率和回访率具有重要意义。 选择专业的产品原型设计工具&#xff0c;可以为团队和企业带来高效的产品设计体验。本文选…
阅读更多...
算法通关村第十四关——解析堆在数组中找第K大的元素的应用

算法通关村第十四关——解析堆在数组中找第K大的元素的应用

力扣215题&#xff0c; 给定整数数组nums和整数k&#xff0c;请返回数组中第k个最大的元素。 请注意&#xff0c;你需要找的是数组排序后的第k个最大的元素&#xff0c;而不是第k个不同的元素。 分析&#xff1a;按照“找最大用小堆&#xff0c;找最小用大堆&#xff0c;找中间…
阅读更多...
亲手实现：全方位解析SpringCloud Alibaba，这份全彩笔记送给你

亲手实现：全方位解析SpringCloud Alibaba，这份全彩笔记送给你

SpringCloud Aliababa简介 大家好&#xff0c;这次我们来分享一个实用的开源项目—SpringCloud Alibaba。 SpringCloud是国内外微服务开发的首选框架&#xff0c;而SpringCloud Alibaba则是阿里巴巴为微服务架构而开发的组件&#xff0c;它支持SpringCloud原生组件&#xff0…
阅读更多...
数据分析三剑客之Numpy

数据分析三剑客之Numpy

数据分析三剑客&#xff1a;Numpy&#xff0c;Pandas&#xff0c;Matplotlib 1.简介 NumPy(Numerical Python) 是 Python 语言的一个扩展程序库&#xff0c;支持大量的维度数组与矩阵运算&#xff0c;此外也针对数组运算提供大量的数学函数库。 numpy是基于c语言开发&#x…
阅读更多...
第二章 进程与线程 一、进程的概念、组成、特征

第二章 进程与线程 一、进程的概念、组成、特征

目录 一、进程的组成 ​编辑 二、概念 程序: 进程&#xff08; Process) : PID: 进程控制块&#xff08;PCB&#xff09;: 三、特征 1、动态性&#xff08;最基本的特性&#xff09; 2、并发性 3、独立性 4、异步性 5、结构性 一、进程的组成 二、概念 程序: 是静…
阅读更多...
针对电子企业的数字工厂管理系统解决方案

针对电子企业的数字工厂管理系统解决方案

随着科技的飞速发展和市场竞争的日益激烈&#xff0c;电子企业需要一种高效、智能的数字工厂管理系统解决方案&#xff0c;以提升生产效率、优化资源利用、降低运营成本&#xff0c;并确保高品质产品的输出。本文将详细探讨针对电子企业的数字工厂管理系统解决方案。 一、数字工…
阅读更多...
页面静态化、Freemarker入门

页面静态化、Freemarker入门

页面静态化介绍 页面的访问量比较大时&#xff0c;就会对数据库造成了很大的访问压力&#xff0c;并且数据库中的数据变化频率并不高。 那需要通过什么方法为数据库减压并提高系统运行性能呢&#xff1f;答案就是页面静态化。页面静态化其实就是将原来的动态网页(例如通过ajax…
阅读更多...
jmeter线程组 bzm - Arrivals Thread Group 阶梯式压测

jmeter线程组 bzm - Arrivals Thread Group 阶梯式压测

简介 BZM - Arrivals Thread Group是jmeter的一个插件&#xff0c;它可以模拟并发到达的用户流量、按时间加压&#xff0c;可以有效地帮助测试人员评估系统在高压力和高并发情况下的性能表现。 插件下载地址&#xff08;jmeter版本不低于 5.2.0 &#xff09;&#xff1a;https:…
阅读更多...
开课吧（三）机器人系统（ros详解）

开课吧（三）机器人系统（ros详解）

目录 常用快捷键&#xff1a; 常用命令&#xff1a; Catkin编译系统&#xff1a; 简析.XML文件&#xff08;说明书&#xff09; name指package名字 version指版本 description指描述 maintainer指拥有者 license指授权 buildtool_depend 依赖catkin编译 build_depend指依…
阅读更多...
【C++】day6学习成果：继承、多态、栈和循环队列

【C++】day6学习成果：继承、多态、栈和循环队列

1.将之前定义的栈类和队列类都实现成模板类 栈&#xff1a; #include <iostream>#define MAX 8using namespace std;template<typename T> class Stack { private:T *data; //栈的数组&#xff0c;指向堆区空间&#xff0c;用于存储栈的容器int top; …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023