C++11中智能指针以及标准模板库 My_string My_stack

news2024/11/16 18:11:13

在这里插入图片描述
My_string.h

#ifndef MY_STRING_H
#define MY_STRING_H

#include <iostream>
#include <cstring>
#include <stdexcept>

using namespace std;

template<typename T>
class My_string {
private:
    T *ptr;         // 指向字符数组的指针
    int size;       // 字符串的最大容量
    int len;        // 字符串当前长度

public:
    My_string();  // 无参构造
    My_string(const T* src);  // 有参构造
    My_string(int num, T value);  // 重复构造
    My_string(const My_string &other);  // 拷贝构造
    My_string &operator=(const My_string &other);  // 拷贝赋值
    ~My_string();  // 析构函数

    void show() const;  // 显示内容
    void isempty() const;  // 判空
    void isfull() const;  // 判满
    void push_back(T value);  // 尾插
    void pop_back();  // 尾删
    T &at(int index);  // at函数实现
    void clear();  // 清空函数
    T* data();  // 返回C风格字符串
    int get_length() const;  // 返回实际长度
    int get_size() const;  // 返回当前最大容量
    void resize();  // 二倍扩容
    My_string operator+(const My_string &R) const;  // 自定义运算符重载 +
    T operator[](int n) 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;
    bool operator!=(const My_string &R) const;

    // 重载 += 运算符
    My_string& operator+=(const My_string &R);

    // 重载输出运算符 <<
    friend ostream& operator<<(ostream &L, const My_string &R) {
        L << R.ptr;
        return L;
    }
};

#include "My_string.cpp"  // 包含实现文件

#endif // MY_STRING_H

My_string.cpp

#include "My_string.h"

// 无参构造
template<typename T>
My_string<T>::My_string() : size(20), len(0) {
    cout << "****************无参构造***********" << endl;
    ptr = new T[size];
    ptr[0] = '\0';  // 表示串为空串
}

// 有参构造
template<typename T>
My_string<T>::My_string(const T* src) {
    cout << "****************一个参数有参构造***********" << endl;
    len = strlen(src);
    size = len + 1;
    ptr = new T[size];
    strcpy(ptr, src);
}

// 初始化字符重复构造
template<typename T>
My_string<T>::My_string(int num, T value) {
    cout << "****************两个参数有参构造***********" << endl;
    len = num;
    size = len + 1;
    ptr = new T[size];
    for (int i = 0; i < num; i++) {
        ptr[i] = value;
    }
    ptr[num] = '\0';
}

// 拷贝构造
template<typename T>
My_string<T>::My_string(const My_string &other) {
    cout << "****************拷贝构造***********" << endl;
    len = other.len;
    size = other.size;
    ptr = new T[size];
    strcpy(ptr, other.ptr);
}

// 拷贝赋值
template<typename T>
My_string<T>& My_string<T>::operator=(const My_string &other) {
    cout << "****************拷贝赋值***********" << endl;
    if (this == &other) {
        return *this;  // 直接返回当前对象
    }
    delete[] ptr;
    len = other.len;
    size = other.size;
    ptr = new T[size];
    strcpy(ptr, other.ptr);
    return *this;
}

// 析构函数
template<typename T>
My_string<T>::~My_string() {
    cout << "****************析构函数***********" << endl;
    delete[] ptr;
}

// 显示内容
template<typename T>
void My_string<T>::show() const {
    cout << "内容: " << ptr << ", 长度: " << len << ", 容量: " << size << endl;
}

// 判空
template<typename T>
void My_string<T>::isempty() const {
    if (len == 0) {
        cout << "字符串为空" << endl;
    }
}

// 判满
template<typename T>
void My_string<T>::isfull() const {
    if (len >= size) {
        cout << "字符串满" << endl;
        resize();
        cout << "重新分配空间" << endl;
    } else {
        cout << "字符串未满" << endl;
    }
}

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

// 尾删
template<typename T>
void My_string<T>::pop_back() {
    if (len > 0) {
        len--;
        ptr[len] = '\0';
    }
}

// at函数实现
template<typename T>
T& My_string<T>::at(int index) {
    if (index < 0 || index >= len) {
        throw out_of_range("Index out of range");
    }
    return ptr[index];
}

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

// 返回C风格字符串
template<typename T>
T* My_string<T>::data() {
    return ptr;
}

// 返回实际长度
template<typename T>
int My_string<T>::get_length() const {
    return len;
}

// 返回当前最大容量
template<typename T>
int My_string<T>::get_size() const {
    return size;
}

// 君子函数:二倍扩容
template<typename T>
void My_string<T>::resize() {
    size *= 2;
    T* new_ptr = new T[size];
    strcpy(new_ptr, ptr);
    delete[] ptr;
    ptr = new_ptr;
}

// 自定义运算符重载 +
template<typename T>
My_string<T> My_string<T>::operator+(const My_string &R) const {
    My_string temp;
    while (this->len + R.len > temp.size) {
        temp.resize();
    }
    strcpy(temp.ptr, this->ptr);
    strcat(temp.ptr, R.ptr);
    temp.len = this->len + R.len;
    return temp;
}

// 自定义运算符重载 []
template<typename T>
T My_string<T>::operator[](int n) const {
    return ptr[n];
}

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

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

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

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

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

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

// 重载 += 运算符
template<typename T>
My_string<T>& My_string<T>::operator+=(const My_string &R) {
    while (this->len + R.len >= this->size) {
        this->resize();
    }
    strcat(this->ptr, R.ptr);
    this->len += R.len;
    return *this;
}

main.cpp

#include "My_string.h"

int main() {
    My_string<char> str1("Hello");
    My_string<char> str2(" World");

    My_string<char> str3 = str1 + str2;
    str3.show();  

    return 0;
}

栈的模板类

My_stack.h

#ifndef MY_STACK_H
#define MY_STACK_H

#include <iostream>
using namespace std;

template<typename T>
class My_Stack {
private:
    T* ptr;         // 动态数组用于存储栈元素
    int top;        // 栈顶索引
    int capacity;   // 当前容量

    void resize();  // 调整栈的大小

public:
    My_Stack();                // 构造函数
    My_Stack(const My_Stack& other);  // 拷贝构造函数
    ~My_Stack();               // 析构函数

    void push(T value);        // 入栈操作
    T pop();                   // 出栈操作
    T peek();                  // 获取栈顶元素
    bool isEmpty();            // 判断栈是否为空
    int size();                // 获取栈的当前大小
    void swap_t(My_Stack& other); // 交换栈
    void show();               // 显示栈中的内容

    My_Stack& operator=(const My_Stack& other);  // 赋值操作符重载
};

#include "My_stack.cpp"  // 引入实现文件

#endif // MY_STACK_H

My_stack.cpp

#include "My_stack.h"

// 构造函数
template<typename T>
My_Stack<T>::My_Stack() : top(-1), capacity(1) {
    ptr = new T[capacity];  // 初始化容量为1
}

// 拷贝构造函数
template<typename T>
My_Stack<T>::My_Stack(const My_Stack& other) : top(other.top), capacity(other.capacity) {
    ptr = new T[capacity];  // 分配新的内存
    for (int i = 0; i <= top; ++i) {
        ptr[i] = other.ptr[i];  // 深拷贝
    }
}

// 析构函数
template<typename T>
My_Stack<T>::~My_Stack() {
    delete[] ptr;  // 释放动态数组的内存
}

// 动态扩容
template<typename T>
void My_Stack<T>::resize() {
    capacity *= 2;  // 容量翻倍
    T* new_arr = new T[capacity];  // 创建新的数组
    for (int i = 0; i <= top; ++i) {
        new_arr[i] = ptr[i];  // 拷贝原数组元素
    }
    delete[] ptr;  // 释放旧数组
    ptr = new_arr;  // 更新指针
}

// 入栈操作
template<typename T>
void My_Stack<T>::push(T value) {
    if (top >= capacity - 1) {
        resize();  // 容量不足时进行扩容
    }
    ptr[++top] = value;  // 增加栈顶并赋值
    cout << "入栈: " << value << endl;
}

// 出栈操作
template<typename T>
T My_Stack<T>::pop() {
    if (isEmpty()) {
        cout << "栈为空！无法出栈。" << endl;
        return T();  // 返回默认值
    }
    T popValue = ptr[top--];  // 返回栈顶值并减少栈顶索引
    cout << "出栈: " << popValue << endl;
    return popValue;
}

// 获取栈顶元素
template<typename T>
T My_Stack<T>::peek() {
    if (isEmpty()) {
        cout << "栈为空！无法查看栈顶元素。" << endl;
        return T();  // 返回默认值
    }
    return ptr[top];  // 返回栈顶值
}

// 判断栈是否为空
template<typename T>
bool My_Stack<T>::isEmpty() {
    return top == -1;  // 栈为空时，栈顶索引为 -1
}

// 获取栈的当前大小
template<typename T>
int My_Stack<T>::size() {
    return top + 1;  // 返回栈中元素的个数
}

// 交换栈
template<typename T>
void My_Stack<T>::swap_t(My_Stack& other) {
    swap(top, other.top);
    swap(capacity, other.capacity);
    swap(ptr, other.ptr);  // 交换指针
}

// 显示栈中的内容
template<typename T>
void My_Stack<T>::show() {
    if (isEmpty()) {
        cout << "栈为空！" << endl;
        return;
    }

    cout << "栈中的元素: ";
    for (int i = 0; i <= top; ++i) {
        cout << ptr[i] << " ";  // 打印每个元素
    }
    cout << endl;
}

// 赋值操作符重载
template<typename T>
My_Stack<T>& My_Stack<T>::operator=(const My_Stack& other) {
    if (this != &other) {  // 自我赋值检查
        delete[] ptr;  // 释放旧数组
        top = other.top;
        capacity = other.capacity;
        ptr = new T[capacity];  // 分配新的内存
        for (int i = 0; i <= top; ++i) {
            ptr[i] = other.arr[i];  // 深拷贝
        }
    }
    return *this;  // 返回当前对象的引用
}

main.cpp

#include "My_stack.h"

int main() {
    // 创建第一个栈并进行入栈操作
        My_Stack<int> s1;
        s1.push(10);
        s1.push(20);
        s1.push(30);

        // 创建第二个栈并进行入栈操作
        My_Stack<int> s2;
        s2.push(40);
        s2.push(50);

        My_Stack<int> s3 = s2;

        cout<<"s3:";
        s3.show();

        cout <<"交换前:"<< endl;
        cout<<"s1:";
        s1.show();
        cout<<"s2:";
        s2.show();

        // 交换s1和s2的内容
        s1.swap_t(s2);
        cout << "交换后:" << endl;

        cout<<"s1:";
        s1.show();
        cout<<"s2:";
        s2.show();

        // 出栈
        cout<<"从 s1 弹出元素: "<<s1.pop()<<endl;
        cout<<"从 s2 弹出元素: "<<s2.pop()<<endl;

        // 检查栈的大小
        cout<<"s1 当前大小: "<<s1.size()<<endl;
        cout<<"s2 当前大小: "<<s2.size()<<endl;

        // 再次弹出元素
        s1.pop();
        s2.pop();

        cout << "交换后再次弹出后的大小:" << endl;
        cout << "s1 当前大小: " << s1.size() << endl;
        cout << "s2 当前大小: " << s2.size() << endl;


    return 0;
}

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

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

相关文章

你的下一台手机会是眼镜吗？RTE 大会与你一同寻找下一代计算平台丨「空间计算和新硬件」论坛报名

你的下一台手机会是眼镜吗？RTE 大会与你一同寻找下一代计算平台丨「空间计算和新硬件」论坛报名

周四 Meta 刚公布新一代 AR 眼镜 Orion 后&#xff0c;Perplexity 的 CEO 发了一条状态&#xff1a;「如果你还在做软件&#xff0c;请转型硬件。」 一家估值 30 亿美元的 AI 软件公司 CEO 说出这样的言论&#xff0c;既有有见到「最强 AR 眼镜」Orion 后的激动情绪&#xff0c…
阅读更多...
【Redis】持久化机制--RDB和AOF

【Redis】持久化机制--RDB和AOF

目录 1. RDB持久化 1.1 触发机制 1.2 流程说明 1.3 RDB文件的处理 1.4 RDB机制演示 1.5 RDB的优缺点 2. AOF持久化 2.1 使用AOF与基本演示 2.2 AOF的工作流程 2.3 文件同步&#xff08;缓冲区刷新策略&#xff09; 2.4 重写机制 2.5 AOF重写流程 2.6 启动时数据恢复 …
阅读更多...
基于Diffusion的图像修复方法

基于Diffusion的图像修复方法

基于Diffusion的图像修复方法 本文介绍基于 Diffusion 的几个图像修复的工作。图像修复任务有两种应用的场景&#xff0c;一是图片的某部分真的缺失了&#xff0c;需要修复处这部分内容&#xff1b;二是想要修改图片中的某个部分&#xff0c;更换/新增/删除物体&#xff0c;这…
阅读更多...
godot4.2入门项目 dodge_the_creep学习记录

godot4.2入门项目 dodge_the_creep学习记录

前言 在学习博客Godot4 你的第一个2d游戏中的项目时&#xff0c;遇到了点小问题&#xff0c;记录一下。 官方项目 传送门 问题 怪兽直接从屏幕中间部分冒出来&#xff0c;以及角色出现时位于屏幕外角色被设置的背景图遮挡 解决方法 1.节点的位置没有对齐&#xff0c;正确示例…
阅读更多...
李宏毅机器学习2022-HW8-Anomaly Detection

李宏毅机器学习2022-HW8-Anomaly Detection

文章目录 TaskBaselineReportQuestion2 Task 异常检测Anomaly Detection 将data经过Encoder&#xff0c;在经过Decoder&#xff0c;根据输入和输出的差距来判断异常图像。training data是100000张人脸照片&#xff0c;testing data有大约10000张跟training data相同分布的人脸…
阅读更多...
9.27每日作业

9.27每日作业

将之前实现的顺序表、栈、队列都更改成模板类 顺序表&#xff1a; list.hpp #ifndef LIST_HPP #define LIST_HPP#include <iostream> #include<memory.h> #include<stdlib.h> #include<string.h> using namespace std;//typedef int T; //类…
阅读更多...
nginx常用的性能优化

nginx常用的性能优化

第一步调整工作进程数&#xff1a; 设置成auto&#xff0c;会自动按照CPU核心数来启动工作进程数&#xff0c;如果设置具体数字&#xff0c;则只会使用指定数量的CPU核心&#xff0c;无法将CPU同一时间都能用得到&#xff0c;所以就不能发挥服务器的最大的性能。 第二步增加进程…
阅读更多...
章管家 listUploadIntelligent.htm SQL注入漏洞

章管家 listUploadIntelligent.htm SQL注入漏洞

漏洞描述&#xff1a; 章管家 listUploadIntelligent.htm 接口处存在SQL注入漏洞&#xff0c;未经身份验证的远程攻击者除了可以利用 SQL 注入漏洞获取数据库中的信息&#xff08;例如&#xff0c;管理员后台密码、站点的用户个人信息&#xff09;之外&#xff0c;甚至在高权限…
阅读更多...
基于大数据的高血压人群数据分析及可视化系统

基于大数据的高血压人群数据分析及可视化系统

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI、Python、小程序等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、Vue项目源码、SSM项目源码 精品专栏&#xff1a;Java精选实战项目…
阅读更多...
MMD模型及动作一键完美导入UE5-衣服布料模拟（四）

MMD模型及动作一键完美导入UE5-衣服布料模拟（四）

1、给角色刷布料 1、打开角色，通过Window->Clothing打开模型布料窗口 2、选中裙子右键，创建布料数据 3、选择裙子，右键->应用布料数据 4、激活布料画笔，就可以开始绘制布料了 5、调整画笔大小和布料值进行绘制，布料值为0表示刚体
阅读更多...
网络安全：保护数字时代的堡垒

网络安全：保护数字时代的堡垒

网络安全&#xff1a;保护数字时代的堡垒 引言&#xff1a; 在数字化时代&#xff0c;网络安全的重要性日益凸显。它不仅关系到个人隐私保护&#xff0c;还涉及国家安全和经济发展。随着技术的发展&#xff0c;网络安全的威胁也在不断进化&#xff0c;从个人设备到企业网络&am…
阅读更多...
2024图纸加密软件集锦|10款好用不踩雷的图纸加密软件推荐！

2024图纸加密软件集锦|10款好用不踩雷的图纸加密软件推荐！

小李&#xff1a;“老张&#xff0c;最近咱们公司的设计图纸泄密事件频发&#xff0c;真是让人头疼啊&#xff01;你有没有什么好的图纸加密软件推荐&#xff0c;能帮我们加强设计文件的安全性&#xff1f;” 老张&#xff1a;“小李啊&#xff0c;你算是问对人了。随着数字化…
阅读更多...
《pyqt+open3d》open3d可视化界面集成到qt中

《pyqt+open3d》open3d可视化界面集成到qt中

《pyqtopen3d》open3d可视化界面集成到qt中 一、效果显示二、代码三、资源下载 一、效果显示 二、代码 参考链接 main.py import sys import open3d as o3d from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget from PyQt5.QtGui import QWindow from PyQt5.Qt…
阅读更多...
高通Android 12 push framework.jar和service.jar

高通Android 12 push framework.jar和service.jar

1、Android framework.jar和service.jar替换注意事项 2、单编 adb push service.jar脚本 如下 adb root adb disable-verity adb remountadb push services.jar system/framework adb push services.jar.prof system/framework adb push oat/arm64/services.art /system/fram…
阅读更多...
重磅首发！大语言模型LLM学习路线图来了！

重磅首发！大语言模型LLM学习路线图来了！

ChatGPT的出现在全球掀起了AI大模型的浪潮&#xff0c;2023年可以被称为AI元年&#xff0c;AI大模型以一种野蛮的方式&#xff0c;闯入你我的生活之中。 从问答对话到辅助编程&#xff0c;从图画解析到自主创作&#xff0c;AI所展现出来的能力&#xff0c;超出了多数人的预料&…
阅读更多...
酒店智能门锁SDK接口pro[V10] 对接酒店收银-模块封装C#-SAAS本地化-未来之窗行业应用跨平台架构

酒店智能门锁SDK接口pro[V10] 对接酒店收银-模块封装C#-SAAS本地化-未来之窗行业应用跨平台架构

一、代码 public class CyberWin_hoteldoor_prousbv10_2024{[DllImport("024.dll", CharSet CharSet.Ansi, CallingConvention CallingConvention.StdCall, EntryPoint "GetDLLVersion")]public static extern int GetDLLVersion(StringBuilder sDllVer…
阅读更多...
新手答疑 | 零基础该怎么学习嵌入式？嵌入式Linux学习路线是什么？嵌入式开发板推荐？

新手答疑 | 零基础该怎么学习嵌入式？嵌入式Linux学习路线是什么？嵌入式开发板推荐？

很多初学者想要涉足嵌入式Linux开发领域&#xff0c;但往往在刚入门阶段&#xff0c;会因为初次接触到大量复杂的概念术语和深奥的技术文档感到压力重重&#xff0c;面对这些内容不知从何下手&#xff0c;感到十分迷茫&#xff0c;网上的内容也纷繁复杂&#xff0c;没有清晰的学…
阅读更多...
【STM32】SPI回顾

【STM32】SPI回顾

一、定义 SPI是Motorola首先提出的全双工四线同步串行外围接口&#xff0c;采用主从模式&#xff08;Master-Slave&#xff09;架构。 二、单机与多机通信 4线SPI器件有四个信号&#xff1a;时钟(SPI CLK, SCLK)、主机输出从机输入(MOSI)、主机输入从机输出(MISO)、片选(CS/N…
阅读更多...
怎么备考2024年11月软考高级系统架构师 ?

怎么备考2024年11月软考高级系统架构师 ?

分享下我的系统架构设计师考证之路&#xff0c;希望能对即将参加考试的小伙伴们带来一些启示和帮助。 先贴出自己软考系统架构设计师成绩&#xff0c;备考一次就通过了考试。 一、架构考试教材 架构考试教材目前使用的是系统架构设计师教程&#xff08;第2版&#xff09;&…
阅读更多...
进程（一万字学习笔记）

进程（一万字学习笔记）

------------------------本文为学习进程记录的学习笔记&#xff0c;如有问题欢迎指正 -------------------------- 目录 1.定义 2.进程的种类 2.进程的内存布局 3.进程控制块&#xff08;PCB&#xff09; 4.进程源语 fork() 写时复制 exec() execl函数 wait() #进…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023