[C++]栈队列改成模板类

news2024/9/27 21:30:50

栈、队列都更改成模板类

栈
.hpp
#ifndef MY_STACK_H
#define MY_STACK_H
#include <iostream>

using namespace std;

template<typename T>
class my_stack
{
private:
    T *base;//动态栈指针
    int top;//栈顶元素
    int size;//栈大小
public:
    my_stack();//无参构造
    my_stack(T size):top(-1),size(size)
    {
        base = new T[this->size];
        cout<<"有参构造"<<endl;
    }
    ~my_stack()
    {
        delete []base;
        cout<<"析构函数"<<endl;
    }

    //赋值
    my_stack<T> & operator=(const my_stack<T> &str);

    //访问栈顶元素
    T my_top();

    //检查容器是否为空
    bool my_empty();

    //返回容纳元素数
    T my_size();
    //插入栈顶
    void my_push(T value);
    //删除栈顶
    void my_pop();
};

//赋值
template<typename T>
my_stack<T> & my_stack<T>::operator=(const my_stack<T> &str)
{
    if(this != &str)
    {
        delete []base;
        this->size = str.size;
        this->top = str.top;
        base = new int[size];
        for(int i = 0;i<size;i++)
        {
            base[i] = str.base[i];
        }
    }
    return *this;
}

//访问栈顶元素
template<typename T>
T my_stack<T>::my_top()
{
    if(my_empty())
    {
        cout<<"栈为空"<<endl;
        return -1;
    }
    return base[top];
}

//检查容器是否为空
template<typename T>
bool my_stack<T>::my_empty()
{
    return top == -1;
}

//返回容纳元素数
template<typename T>
T my_stack<T>::my_size()
{
    return top+1;
}
//插入栈顶
template<typename T>
void my_stack<T>::my_push(T value)
{
    if(top >= size)
    {
        cout<<"栈满"<<endl;
        return;
    }
    base[++top] = value;
    cout<<value<<"插入成功"<<endl;
}
//删除栈顶
template<typename T>
void my_stack<T>::my_pop()
{
    if(my_empty())
    {
        cout<<"栈为空"<<endl;
        return;
    }
    top--;
    cout<<"删除栈顶成功"<<endl;
}

#endif // MY_STACK_H
主程序
#include "my_stack.hpp"
int main()
{
    my_stack<int> s(10);
    s.my_push(23);
    s.my_push(45);
    s.my_push(74);

    cout<<"栈顶 = "<<s.my_top()<<endl;
    cout<<"栈元素个数="<<s.my_size()<<endl;
    s.my_pop();
    cout<<"删除栈顶后栈元素个数="<<s.my_size()<<endl;
    return 0;
}
队列
.hpp
#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>

using namespace std;

template<typename T>
class queue
{
private:
    T *base;//队列动态数组
    int front;//头部
    int rear;//尾部
    int size;//容器大小
public:
    queue();//无参构造
    queue(T size):front(0),rear(0),size(size)//有参构造
    {
        base = new T[size];
        cout<<"有参构造"<<endl;
    }
    //析构函数
    ~queue()
    {
        delete [] base;
        cout<<"析构函数"<<endl;
    }

    //赋值
    queue<T> &operator=(const queue<T> &str);
    //访问第一个元素
    T my_front();
    //访问最后一个元素
    T my_back();
    //检查容器是否为空
    bool my_empty();
    //返回容器的元素数
    T my_size();
    //向队尾插入元素
    void my_push(T value);
    //删除首个插入元素
    void my_pop();
};

//赋值
template<typename T>
queue<T> & queue<T>::operator=(const queue<T> &str)
{
    if(this != &str)
    {
        delete []base;
        front = str.front;
        rear = str.rear;
        size = str.size;
        base = new int[size];
        for(int i = front;i<rear;i++)
        {
            base[i] = str.base[i];
        }
    }
    return *this;
}
//访问第一个元素
template<typename T>
T queue<T>::my_front()
{
    if(my_empty())
    {
        cout<<"队列为空"<<endl;
        return -1;
    }
    return base[front];
}
//访问最后一个元素
template<typename T>
T queue<T>::my_back()
{
    if(my_empty())
    {
        cout<<"队列为空"<<endl;
        return -1;
    }
    return base[rear-1];
}
//检查容器是否为空
template<typename T>
bool queue<T>::my_empty()
{
    return rear == front;
}
//返回容器的元素数
template<typename T>
T queue<T>::my_size()
{
    return rear-front;
}
//向队尾插入元素
template<typename T>
void queue<T>::my_push(T value)
{
    base[rear++] = value;
    cout<<"插入成功"<<endl;
}
//删除首个插入元素
template<typename T>
void queue<T>::my_pop()
{
    if(my_empty())
    {
        cout<<"队列为空"<<endl;
        return;
    }
    cout<<"首元素"<<base[front++]<<"删除成功"<<endl;
}

#endif // QUEUE_H
主程序
#include "queue.hpp"

int main()
{
    queue<int> s(10);
    s.my_push(14);
    s.my_push(24);
    s.my_push(41);
    s.my_push(4);
    cout<<"最后一个元素是"<<s.my_back()<<endl;
    s.my_pop();
    cout<<"第一个元素"<<s.my_front()<<endl;
    return 0;
}
顺序表
.hpp
#ifndef SEQLIST_H
#define SEQLIST_H


#include <iostream>
#include <cstring>
using namespace std;
template<typename T>
class My_string
{
private:
    T *ptr; //顺序表字符数组
    int size = 15;     //数组的最大
    int len;  //数组的实际长度

public:
    My_string();    //无参构造

    //有参构造
    My_string(const T* src);

    My_string(T num,T value);
    //拷贝构造
    My_string(const My_string &other);
    //拷贝赋值
    My_string &operator = (const My_string &other);
    //析构函数
    ~My_string();
    bool empty();      //判空

    void push_back(T value); //尾插

    void pop_back(); //尾删

    T listsize();  //求长度

    T & at(T inex);  //获取任意位置元素

    void clear();//清空

    T *data();//返回C风格字符串

    T get_length();//返回当前最大容器
    void show();         //展示
    void append(const T *ptr);//扩容
    const My_string operator+(const My_string &other)const;//+运算符重载
    T &operator[](T n);//[]运算符重载
    bool operator>(const My_string &R)const;//>重载
    bool operator<(const My_string &R)const;//<重载
    bool operator==(const My_string &R)const;//==重载
    bool operator>=(const My_string &R)const;//>=重载
    bool operator<=(const My_string &R)const;//<=重载
    bool operator!=(const My_string &R)const;//!=重载
    My_string &operator +=(const My_string &R);//+=重载

    friend ostream &operator<<(ostream &L,const My_string &R);
    friend istream &operator>>(istream &L, My_string &R);
};

template<typename T>
My_string<T>::My_string():size(15)     //无参构造
{
    this->ptr = new char[size];
    this->ptr[0] = '\0';
    this->len = 0;
}
//有参构造
template<typename T>
My_string<T>::My_string(const T* src)
{
    len = strlen(src)+1;
    size = len >size?size*2:size;
    this->ptr = new char[size];
    strcpy(ptr,src);
}
template<typename T>
My_string<T>::My_string(T num,T value)
{
    size = num >size?size*2:size;
    ptr = new char[size];
    for(int i = 0;i<num;i++)
    {
        this->ptr[i] = value;
    }
    this->len = num;
}
//拷贝构造
template<typename T>
My_string<T>::My_string(const My_string &other):ptr(new char[other.size]),size(other.size),len(other.len)
{
    strcpy(this->ptr,other.ptr);
    this->size = other.size;
    this->len = other.len;
}
//拷贝赋值
template<typename T>
My_string<T> &My_string<T>::operator = (const My_string<T> &other)
{
    if(this != &other)
    {
        delete []ptr;
        size = other.size;
        ptr = new char[size + 1];
        strcpy(ptr,other.ptr);
    }
    return *this;
}
//析构函数
template<typename T>
My_string<T>::~My_string()
{
    delete []ptr;
}
template<typename T>
T *My_string<T>::data()//返回C风格字符串
{
    return ptr;
}
//判空
template<typename T>
bool My_string<T>::empty()
{
    return ptr[0] == 0;
}

//尾插
template<typename T>
void My_string<T>::push_back(T value)
{
    this->ptr[len++] = value;
}

//尾删
template<typename T>
void My_string<T>::pop_back()
{
    if(this->empty())
    {
        cout<<"表为空无删除对象"<<endl;
        return;
    }
    this->len--;
}
//求长度
template<typename T>
T My_string<T>::listsize()
{
    return this->len;
}
//获取任意位置元素
template<typename T>
T & My_string<T>::at(T index)
{
    if(this->empty())
    {
        throw std::out_of_range("表为空无对象");
    }
    if(index>this->len||index<=0)
    {
        throw std::out_of_range("位置错误");
    }
    return this->ptr[index-1];
}

//展示
template<typename T>
void My_string<T>::show()
{
    if(this->empty())
    {
        cout<<"表为空无对象"<<endl;
        return;
    }
    cout<<"当前顺序表中的元素是：";

    cout<<"ptr = "<<ptr<<" ";
    len = strlen(ptr);
    cout<<"len = "<<len<<endl;
}
template<typename T>
T My_string<T>::get_length()//返回当前最大容器
{
    return this->size;
}

template<typename T>
void My_string<T>::clear()//清空
{
    delete []ptr;
    ptr = new char[1];
    ptr[0] = '\0';
    len = 0;
}

template<typename T>
void My_string<T>::append(const T *src)
{
    int src_len = strlen(src);
    while(len+src_len >= size)
    {
        size *= 2;
        char *new_ptr = new char[size];
        strcpy(new_ptr,ptr);
        delete []ptr;
        ptr = new_ptr;
    }
    strcat(ptr,src);
    len += src_len;
}

template<typename T>
const My_string<T> My_string<T>::operator+(const My_string<T> &other)const//+运算符重载
{
    My_string temp;
    delete []temp.ptr;
    temp.len =this->len+other.len;
    temp.ptr = new char(temp.len+1);
    strcpy(temp.ptr,this->ptr);
    strcat(temp.ptr,other.ptr);

    return temp;

}

template<typename T>
T &My_string<T>::operator[](T n)//[]运算符重载
{
    if(n<0||n>len)
    {
        cout<<"数组越界"<<endl;
    }
    else
    {
        return ptr[n-1];
    }
}

template<typename T>
bool My_string<T>::operator>(const My_string<T> &R)const//>重载
{
    return strcmp(this->ptr,R.ptr)>0;
}

template<typename T>
bool My_string<T>::operator<(const My_string<T> &R)const//<重载
{
    return strcmp(this->ptr,R.ptr)<0;
}

template<typename T>
bool My_string<T>::operator==(const My_string<T> &R)const//==重载
{
    return strcmp(this->ptr,R.ptr)==0;
}

template<typename T>
bool My_string<T>::operator>=(const My_string<T> &R)const//>=重载
{
    return strcmp(this->ptr,R.ptr)>=0;
}

template<typename T>
bool My_string<T>::operator<=(const My_string<T> &R)const//<=重载
{
    return strcmp(this->ptr,R.ptr)<=0;
}

template<typename T>
bool My_string<T>::operator!=(const My_string<T> &R)const//!=重载
{
    return strcmp(this->ptr,R.ptr)!=0;
}

template<typename T>
My_string<T> &My_string<T>::operator +=(const My_string<T> &R)//+=重载
{
    My_string temp;
    temp.ptr = new char(len+1);
    strcpy(temp.ptr,this->ptr);
    temp.len = this->len;
    delete [] ptr;
    this->ptr = new char(temp.len+R.len+1);
    strcpy(ptr,temp.ptr);
    strcat(ptr,R.ptr);
    return  *this;
}


#endif // SEQLIST_H
 主程序
 
#include "seqlist.hpp"
int main()
{
    My_string<char> s1("Hello");
    //拷贝构造
    My_string<char> s2 = s1;
    s2.show();

    //无参构造
    My_string<char> s3;
    //拷贝赋值
    s3 = s1;
    s3.show();
    s3.push_back('a');
    //C字符风格
    cout<<s3.data()<<endl;
    s3.pop_back();

    s3.append(" world ,good");
    s3.show();
    //求实际长度
    cout<<"s3容器的实际长度 = "<<s3.listsize()<<endl;
    cout<<"s3容器的最大长度 = "<<s3.get_length()<<endl;

    cout<<"s3容器2号元素= "<<s3.at(2)<<endl;
    //clear
    s3 = s2+s1;
    s3.show();
    cout<<"s3[2]= "<<s3[2]<<endl;
    My_string<char> s4("good");
    return 0;
}

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

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

相关文章

宠物空气净化器有必要买吗？希喂、霍尼韦尔和352哪款更推荐？

宠物空气净化器有必要买吗？希喂、霍尼韦尔和352哪款更推荐？

国庆假终于要来了&#xff0c;对于我这个上班族而言&#xff0c;除了春节假期最期待的就是这个国庆假&#xff0c;毕竟假期这么长&#xff0c;家里还有一只小猫咪&#xff0c;一直都没时间陪它&#xff0c;终于给我找到时间带它会老家玩一趟了。 我跟我妈说的时候&#xff0c;…
阅读更多...
Apache OFBiz SSRF漏洞CVE-2024-45507分析

Apache OFBiz SSRF漏洞CVE-2024-45507分析

Apache OFBiz介绍 Apache OFBiz 是一个功能丰富的开源电子商务平台&#xff0c;包含完整的商业解决方案&#xff0c;适用于多种行业。它提供了一套全面的服务&#xff0c;包括客户关系管理&#xff08;CRM&#xff09;、企业资源规划&#xff08;ERP&#xff09;、订单管理、产…
阅读更多...
Vulhub TheEther_1.0.1靶机详解

Vulhub TheEther_1.0.1靶机详解

项目地址 https://download.vulnhub.com/theether/theEther_1.0.1.zip实验过程 将下载好的靶机导入到VMware中&#xff0c;设置网络模式为NAT模式&#xff0c;然后开启靶机虚拟机 使用nmap进行主机发现&#xff0c;获取靶机IP地址 nmap 192.168.47.1-254根据对比可知theEthe…
阅读更多...
【 EXCEL 数据处理 】000003 案列 标记涨跌，保姆级教程。使用的软件是微软的Excel操作的。处理数据的目的是让数据更直观的显示出来，方便查看。

【 EXCEL 数据处理 】000003 案列 标记涨跌，保姆级教程。使用的软件是微软的Excel操作的。处理数据的目的是让数据更直观的显示出来，方便查看。

【 EXCEL 数据处理 】000003 案列 使用条件格式之大于和小于&#xff0c;标记涨跌&#xff0c;保姆级教程。使用的软件是微软的Excel操作的。处理数据的目的是让数据更直观的显示出来&#xff0c;方便查看。 &#x1f4da;一、直接上案例 &#x1f4d6;1.使用条件格式之大于和小…
阅读更多...
CMU 10423 Generative AI：lec7、8、9（专题2：一张图理解diffusion model结构、代码实现和效果）

CMU 10423 Generative AI：lec7、8、9（专题2：一张图理解diffusion model结构、代码实现和效果）

本文介绍diffusion model是什么&#xff08;包括&#xff1a;模型详细的架构图、各模块原理和输入输出、训练算法解读、推理算法解读&#xff09;、以及全套demo代码和效果。至于为什么要这么设计、以及公式背后的数学原理&#xff0c;过程推导很长很长&#xff0c;可见参考资料…
阅读更多...
Bug：ThreadPoolTaskScheduler搭配CronTask完成定时任务，关闭scheduler后CronTask任务仍然执行？

Bug：ThreadPoolTaskScheduler搭配CronTask完成定时任务，关闭scheduler后CronTask任务仍然执行？

【问题】执行下面代码后&#xff0c;关闭ThreadPoolTaskScheduler&#xff0c;CronTask仍然继续执行。 Configuration public class config {Beanpublic String getString() throws InterruptedException {Runnable runnable () -> {try {System.out.println("hello r…
阅读更多...
动态规划算法：13.简单多状态 dp 问题_打家劫舍II_C++

动态规划算法：13.简单多状态 dp 问题_打家劫舍II_C++

目录 题目链接&#xff1a;LCR 090. 打家劫舍 II - 力扣&#xff08;LeetCode&#xff09; 一、题目解析 题目&#xff1a; 解析&#xff1a; 二、算法原理 1、状态表示 2、状态转移方程 状态转移方程推理&#xff1a; 1、i位置状态分析 2、首尾状态分析 3、初始化 d…
阅读更多...
Meta震撼发布Llama3.2大规模模型

Meta震撼发布Llama3.2大规模模型

在2024.9.26的年Meta Connect大会上&#xff0c;Meta正式推出了Llama3.2模型&#xff0c;旨在提升边缘AI和视觉任务的能力。Llama3.2系列包括11亿和90亿参数的中型视觉模型&#xff0c;以及为移动设备优化的1亿和3亿参数的小型模型&#xff0c;并针对高通和联发科的硬件平台进行…
阅读更多...
Webpack 介绍

Webpack 介绍

Webpack 介绍 Date: August 29, 2024 全文概要 Webpack概念&#xff1a; Webpack是一个静态的模块化的打包工具&#xff0c;可以为现代的 JavaSript 应用程序进行打包。 1-静态&#xff1a;Webpack可以将代码打包成最终的静态资源 2-模块化&#xff1a;webpack支持各种模块…
阅读更多...
教师工作量评估与管理软件

教师工作量评估与管理软件

2相关技术 2.1 MYSQL数据库 MySQL是一个真正的多用户、多线程SQL数据库服务器。 是基于SQL的客户/服务器模式的关系数据库管理系统&#xff0c;它的有点有有功能强大、使用简单、管理方便、安全可靠性高、运行速度快、多线程、跨平台性、完全网络化、稳定性等&#xff0c;非常…
阅读更多...
Spring异常处理-@ExceptionHandler-@ControllerAdvice-全局异常处理

Spring异常处理-@ExceptionHandler-@ControllerAdvice-全局异常处理

文章目录 ResponseBodyControllerAdvice最终的异常处理方式 异常的处理分两类 编程式处理&#xff1a;也就是我们的try-catch 声明式处理&#xff1a;使用注解处理 ResponseBody /*** 测试声明式异常处理*/ RestController public class HelloController {//编程式的异常处理&a…
阅读更多...
EasyAR自定义相机RTSP视频流(CustomCamera)

EasyAR自定义相机RTSP视频流(CustomCamera)

EasyAR可以使用视频源作为输入源&#xff0c;官方给出了示例和文档&#xff0c;但是对于大部分Unity开发人员来说看了文档还是一头雾水。 在Android Studio中将custom-camera.jar添加libs中&#xff0c;就可以查看源代码了 分析其源代码&#xff0c;主要是ExternalCameraSampl…
阅读更多...
【linux 多进程并发】linux下使用常见命令，来解析进程家族体系脉络

【linux 多进程并发】linux下使用常见命令，来解析进程家族体系脉络

0101 Linux进程 ​专栏内容&#xff1a; postgresql使用入门基础手写数据库toadb并发编程 个人主页&#xff1a;我的主页 管理社区&#xff1a;开源数据库 座右铭&#xff1a;天行健&#xff0c;君子以自强不息&#xff1b;地势坤&#xff0c;君子以厚德载物. 文章目录 0101 Li…
阅读更多...
ASP.NET Core 打包net8.0框架在Linux CentOS7上部署问题

ASP.NET Core 打包net8.0框架在Linux CentOS7上部署问题

问题1 libstdc.so.6版本过低。 CentOS7默认安装的gcc版本太低&#xff0c;达不到.net8的启动条件。 /lib64/libstdc.so.6: version GLIBCXX_3.4.20’ not found (required by ./IDT_net) /lib64/libstdc.so.6: version GLIBCXX_3.4.21’ not found (required by ./IDT_net) 解…
阅读更多...
恢复丢失的数据:恢复数据库网络解决方案

恢复丢失的数据:恢复数据库网络解决方案

探索恢复数据库网络的深度对于了解现代企业如何防御其数据不断增长的威胁至关重要。在一个时代&#xff0c;数字证据和取证网络安全在法律和商业领域扮演关键角色&#xff0c;这些网络提供的弹性是不可或缺的。深入研究恢复数据库网络的重要性不仅仅是数据保护&#xff0c;它还…
阅读更多...
ubuntu安装mysql 8，mysql密码的修改

ubuntu安装mysql 8，mysql密码的修改

目录 1.安装mysql 82.查看当前状态3.手动给数据库设置密码mysql5mysql8 4.直接把数据库验证密码的功能关闭掉 1.安装mysql 8 apt install mysql-server-8.0敲 Y 按回车 table 选ok 2.查看当前状态 service mysql status显示active&#xff08;running&#xff09;证明安装成…
阅读更多...
媒界：吉利星瑞百炼成钢，持续引领中国汽车价值向上

媒界：吉利星瑞百炼成钢，持续引领中国汽车价值向上

秋风送爽绘秋色&#xff0c;出行良辰恰逢时。9月28日至9月29日&#xff0c;2024安行中国汽车安全科技公益巡展迎来尾声&#xff0c;安行中国携手吉利汽车&#xff0c;步履轻盈地踏入苏州星湖天街&#xff0c;共同呈献一场融合环保科技前沿、安全驾驶理念与深厚文化底蕴的48小时…
阅读更多...
使用jQuery处理Ajax

使用jQuery处理Ajax

使用jQuery处理Ajax HTTP协议 超文本传输协议&#xff08;HTTP&#xff0c;HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议 设计HTTP最初的目的是为了提供一种发布和接收HTML页面的方法 所有的WWW文件都必须遵守这个标准 一次HTTP操作称为一个事务&am…
阅读更多...
如何使用 CCF Communicator 框架快速开发设备接口

如何使用 CCF Communicator 框架快速开发设备接口

什么是 CCF Communicator Framework&#xff1f; 通信器框架通过封装 CCF 和设备之间的连接&#xff0c;简化了硬件之间的低级消息处理。 举例来说&#xff0c;考虑一下控制软件和硬件设备之间的连接方式。ASCII 串行连接需要使用 TCP 的套接字连接、用于处理设备发送/接收的…
阅读更多...
肺癌类器官培养研究概述

肺癌类器官培养研究概述

前 言 2023年是类器官被《Science》杂志评为年度十大技术的10周年。10年后类器官技术发展迅猛&#xff0c;犹如一颗璀璨的明珠&#xff0c;不断的为生命科学研究揭示新的奥秘&#xff0c;推动生物医学领域不断前行。肺类器官培养条件也在不断完善&#xff0c;在基础和临床研究…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023