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

于 2024-09-27 22:05:52 发布
阅读量98 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GSCSDNeo/article/details/142603299
版权

在这里插入图片描述
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;
}
GSCSDNeo
关注
C++ STL 标准模板库介绍与入门
dvlinker的技术专栏
05-14 2万+
C++ STL 标准模板库概述与入门
C++模板与STL库介绍
03-18
接下来，我们讨论C++的STL（Standard Template Library，标准模板库）。STL是C++标准库的一部分，包含了一系列高效的数据结构和算法，如容器、迭代器、算法和函数对象。主要的容器有： 1. **向量(Vector)**：动态...
C++ STL(Standard Template Library) 标准模板库
mingo_敏
07-14 1079
list（链表容器）：是一个长度可变的、由 T 类型元素组成的序列，它以双向链表的形式组织元素，在这个序列的任何地方都可以高效地增加或删除元素（时间复杂度都为常数阶 O(1)），但访问容器中任意元素的速度要比前三种容器慢，这是因为 list 必须从第一个元素或最后一个元素开始访问，需要沿着链表移动，直到到达想要的元素。使用此容器，在尾部增加或删除元素的效率最高（时间复杂度为 O(1) 常数阶），在其它位置插入或删除元素效率较差（时间复杂度为 O(n) 线性阶，其中 n 为容器中元素的个数）；
C++标准模板库(STL)——queue、priority_queue、stack、pair、algorithm头文件下的常用函数
weixin_46025531的博客
02-07 1526
文章目录一、queue二、priority_queue 一、queue queue为队列，具有先进先出的特性。使用queue，需要添加#include< queue >和using namespace std; 1、queue的定义： queue<typename> name;//typename可以是任意基本数据类型或容器 queue元素的访问： 由于queue本身就是一种先进先出的限制性数据结构，所以STL只能够提供front()来访问队首元素，用back()来访问队尾元素
【C++学习四】对于C++模板与智能指针的理解
Yann的博客
11-17 1312
文章目录初识C++之：模板与智能指针1.函数模板1.1 一般模板函数1.2 特化模板函数2.类模板2.1 成员模板函数成员模板函数特化2.2 模板类特化全特化偏特化3.智能指针 初识C++之：模板与智能指针 在日常编程过程中，无论是定义变量，类成员，还是定义某个函数的传入参数或return类型，亦或者类中的某个实现方法。一般情况下我们都需要赋予这些参数具体的类型(可以是int， float或是某个class)，然而在很多情况下，某些函数除了传入参数以外，其中的实现方法其实完全相同。这时候，一般有两种解决方案
C++标准库和标准模板库
热门推荐
好儿郎~志在四方
04-14 1万+
（1）成本：已经作为标准提供，何苦再花费时间、人力重新开发呢； （2）质量：标准库的都是经过严格测试的，正确性有保证； （3）效率：关于人的效率已经体现在成本中了，关于代码的执行效率要相信实现标准库的大牛们的水平； （4）良好的编程风格：采用行业中普遍的做法进行开发。
C++ 标准模板库（Standard Template Library，STL）
小嗷犬的博客
04-21 2144
C++ 标准模板库StandardTemplateLibrary）是 C++ 标准库的一部分，不需要另外安装，直接导入即可使用。STL 为程序员提供了通用的模板类，这些模板类可以用来实现各种数据结构和算法，从而使程序员不必从头开始编写这些代码。STL 很好地实现了数据结构和算法的分离，大大降低了模块之间的耦合度，程序员可以自由组合 STL 提供的数据结构和算法。容器（Containers）：各种数据结构，如vectordequemapset等。算法（Algorithms）
【C++高阶】：智能指针的全面解析
island1314的博客
08-07 1303
以上就是智能指针的全部内容啦，后面我会单独出一篇关于自定义删除器的博客，敬请期待咯！！！💞 💞 💞！！祝大家天天开心。
《C++ Primer Plus》学习笔记-string类和标准模板库
qq_44043868的博客
03-03 761
第16章 string类和标准模板库（本书附录G有详细介绍） 16.1 string类 string类是由头文件string支持的。 string类位于命名空间std中。 ctor标识是传统C++中构造函数的缩写。NBTS是以空字符结束的传统C字符串的缩写。 16.1.1 构造字符串（string的构造函数） 可以使用+运算符直接将两个string对象拼接。 16.1.2 string类输入（两种方式） string stuff; cin >> stuff; // 第一种方式 getline(c
（C++）STL(标准模板库)
weixin_53812805的博客
06-01 1073
容器
C++标准库：STL以及输入输出库，IO库，Cmath库，时间库，智能指针库与并发库等简介
追赶时代的博客
06-21 1683
c++标准库 STL cmath chrono iostream thread mutex condition_variablecondition_variable
C++栈(stack)的模板类实现代码
08-30
在C++标准库中，`<stack>`提供了栈的模板类实现，但这里我们将讨论如何使用C++自定义模板类来实现一个简单的栈。 首先，栈的基本操作包括： 1. `push`：将元素添加到栈顶。 2. `pop`：移除栈顶元素并返回其值。 3. ...
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 975
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 993
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
pyqt瀑布流布局
weixin_54217201的博客
09-21 475
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 352
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
ubuntu22上C/C++程序使用weston+wayland+OpenGLES渲染
最新发布
Flying_Motor的博客
09-27 226
一，安装依赖软件：sudo apt install zlib1g-dev libssl-dev libgles2-mesa-dev libsystemd-dev libpng-dev libglib2.0-dev libwayland-dev weston libweston-9-dev。
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 674
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
Python对于C语言使用者来说的反直觉特性
m0_62710548的博客
09-22 731
在编程领域，从一种语言转向另一种语言总是伴随着一系列的学习和调整。对于习惯了C语言严谨性的程序员来说，转向Python可能会遇到一些令人惊讶的特性。以下是我在短暂学习了一段时间python后察觉到的一些python的特性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值