【C++】string类模拟实现(超详细解析，小白必看系列）

最新推荐文章于 2024-10-13 12:52:22 发布
最新推荐文章于 2024-10-13 12:52:22 发布
阅读量352 收藏 1
点赞数 6
分类专栏： c++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73494049/article/details/142172464
版权

模拟实现 C++ 标准库中的 std::string 类是一个很好的练习，可以帮助深入理解 C++ 的内存管理和面向对象编程。

1 浅拷贝和深拷贝解析

浅拷贝和深拷贝是对象复制中的两种不同机制，理解它们的区别对于编写高效、无误的代码至关重要。

浅拷贝 (Shallow Copy)

浅拷贝是指创建一个新对象，这个新对象有着原始对象属性值的一份精确拷贝。如果属性是基本数据类型，拷贝的就是基本数据类型的值；如果属性是引用类型，拷贝的就是内存地址。因此，浅拷贝后的新对象和原对象共享同一块内存，修改一个对象可能会影响另一个对象。

示例：

#include <iostream>
#include <cstring>

class ShallowCopy {
public:
    ShallowCopy(const char* data) {
        _data = new char[strlen(data) + 1];
        strcpy(_data, data);
    }

    ShallowCopy(const ShallowCopy& other) {
        _data = other._data; // 仅复制指针
    }

    ~ShallowCopy() {
        delete[] _data;
    }

    void print() const {
        std::cout << _data << std::endl;
    }

private:
    char* _data;
};

int main() {
    ShallowCopy obj1("Hello");
    ShallowCopy obj2 = obj1; // 浅拷贝

    obj1.print(); // 输出: Hello
    obj2.print(); // 输出: Hello

    return 0;
}

深拷贝 (Deep Copy)

深拷贝是指创建一个新对象，并递归地复制所有对象的属性。新的对象与原始对象没有任何关联，修改一个对象不会影响另一个对象。

示例：

#include <iostream>
#include <cstring>

class DeepCopy {
public:
    DeepCopy(const char* data) {
        _data = new char[strlen(data) + 1];
        strcpy(_data, data);
    }

    DeepCopy(const DeepCopy& other) {
        _data = new char[strlen(other._data) + 1];
        strcpy(_data, other._data); // 复制内容
    }

    ~DeepCopy() {
        delete[] _data;
    }

    void print() const {
        std::cout << _data << std::endl;
    }

private:
    char* _data;
};

int main() {
    DeepCopy obj1("Hello");
    DeepCopy obj2 = obj1; // 深拷贝

    obj1.print(); // 输出: Hello
    obj2.print(); // 输出: Hello

    return 0;
}

区别总结

  • 浅拷贝：复制对象的引用，两个对象共享同一块内存，修改一个对象会影响另一个对象。
  • 深拷贝：复制对象的内容，两个对象独立存在，修改一个对象不会影响另一个对象。

2 代码实现

1. 引入必要的头文件

#include <cstring> // 用于strlen, strcpy, strcmp, memmove, memcpy, memset等函数
#include <cassert> // 用于assert断言检查
#include <algorithm> // 用于std::swap交换函数

2. 类定义及类型别名

class string {
public:
    typedef char* iterator; // 定义迭代器类型，方便遍历字符串

3. 构造函数

    // 默认构造函数，初始化为空字符串或给定的C风格字符串
    string(const char* str = "") {
        _size = strlen(str);
        _capacity = _size;
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }

4. 复制构造函数与赋值操作符

    // 复制构造函数，使用copy-and-swap技巧
    string(const string& s) : _str(nullptr), _size(0), _capacity(0) {
        string tmp(s._str); // 创建一个临时对象
        this->swap(tmp); // 与临时对象交换数据
    }

    // 复制赋值操作符，同样使用copy-and-swap技巧
    string& operator=(string s) {
        this->swap(s); // 与传入的对象交换数据
        return *this;
    }

5. 析构函数

    // 析构函数，释放分配的内存
    ~string() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }

6. 迭代器支持

    // 迭代器支持，用于遍历字符串
    iterator begin() { return _str; }
    iterator end() { return _str + _size; }

7. 修改操作

    // 在字符串末尾添加一个字符
    void push_back(char c) {
        if (_size == _capacity)
            reserve(_capacity * 2); // 如果容量不足，增加容量

        _str[_size++] = c;
        _str[_size] = '\0'; // 空终止符
    }

    // 重载+=操作符，用于添加单个字符
    string& operator+=(char c) {
        push_back(c);
        return *this;
    }

8. 字符串附加操作

    // 附加一个C风格字符串
    void append(const char* str) {
        size_t len = strlen(str);
        if (_size + len > _capacity)
            reserve(_size + len); // 确保有足够的容量

        strcat(_str, str); // 追加字符串
        _size += len;
    }

    // 重载+=操作符，用于附加C风格字符串
    string& operator+=(const char* str) {
        append(str);
        return *this;
    }

9. 清空字符串

    // 清空字符串
    void clear() {
        _size = 0;
        _str[_size] = '\0'; // 空终止符
    }

10. 交换操作

    // 交换两个字符串的数据
    void swap(string& s) {
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }

11. 获取C风格字符串

    // 获取C风格字符串
    const char* c_str() const {
        return _str;
    }

12. 容量相关操作

    // 获取字符串的大小、容量和是否为空
    size_t size() const { return _size; }
    size_t capacity() const { return _capacity; }
    bool empty() const { return _size == 0; }

    // 调整字符串的大小
    void resize(size_t newSize, char c = '\0') {
        if (newSize > _size) {
            if (newSize > _capacity)
                reserve(newSize); // 确保有足够的容量

            memset(_str + _size, c, newSize - _size);
        }

        _size = newSize;
        _str[newSize] = '\0'; // 空终止符
    }

    // 预留内存空间
    void reserve(size_t newCapacity) {
        if (newCapacity > _capacity) {
            char* str = new char[newCapacity + 1];
            strcpy(str, _str); // 复制现有字符串

            delete[] _str; // 释放旧的内存
            _str = str;
            _capacity = newCapacity;
        }
    }

13. 访问操作符

    // 方括号访问操作符
    char& operator[](size_t index) {
        assert(index < _size);
        return _str[index];
    }

    const char& operator[](size_t index) const {
        assert(index < _size);
        return _str[index];
    }

14. 字符串比较操作符

    // 字符串比较操作符
    bool operator<(const string& s) {
        return strcmp(_str, s._str) < 0;
    }

    bool operator<=(const string& s) {
        return strcmp(_str, s._str) <= 0;
    }

    bool operator>(const string& s) {
        return strcmp(_str, s._str) > 0;
    }

    bool operator>=(const string& s) {
        return strcmp(_str, s._str) >= 0;
    }

    bool operator==(const string& s) {
        return strcmp(_str, s._str) == 0;
    }

    bool operator!=(const string& s) {
        return strcmp(_str, s._str) != 0;
    }

15. 字符串查找操作

    // 查找单个字符或子字符串
    size_t find(char c, size_t pos = 0) const {
        for (size_t i = pos; i < _size; ++i) {
            if (_str[i] == c) {
                return i;
            }
        }
        return string::npos; // 未找到
    }

    size_t find(const char* s, size_t pos = 0) const {
        size_t len = strlen(s);
        for (size_t i = pos; i <= _size - len; ++i) {
            if (strncmp(_str + i, s, len) == 0) {
                return i;
            }
        }
        return string::npos; // 未找到
    }

16. 插入操作

    // 在指定位置插入单个字符或子字符串
    string& insert(size_t pos, char c) {
        if (pos > _size) {
            throw std::out_of_range("Position out of range");
        }

        if (_size + 1 > _capacity) {
            reserve(_size + 1); // 确保有足够的容量
        }

        memmove(_str + pos + 1, _str + pos, _size - pos + 1);
        _str[pos] = c;
        ++_size;
        return *this;
    }

    string& insert(size_t pos, const char* str) {
        size_t len = strlen(str);
        if (pos > _size) {
            throw std::out_of_range("Position out of range");
        }

        if (_size + len > _capacity) {
            reserve(_size + len); // 确保有足够的容量
        }

        memmove(_str + pos + len, _str + pos, _size - pos + 1);
        memcpy(_str + pos, str, len);
        _size += len;
        return *this;
    }

17. 删除操作

    // 删除指定位置的字符或子字符串
    string& erase(size_t pos, size_t len) {
        if (pos > _size || pos + len > _size) {
            throw std::out_of_range("Position out of range");
        }

        memmove(_str + pos, _str + pos + len, _size - pos - len + 1);
        _size -= len;
        return *this;
    }

18. 友元函数：输入输出流操作

private:
    friend ostream& operator<<(ostream& _cout, const string& s); // 输出流操作符
    friend istream& operator>>(istream& _cin, string& s); // 输入流操作符

    char* _str;
    size_t _capacity;
    size_t _size;
};

19. 输出流操作符

// 输出流操作符，用于输出字符串
ostream& operator<<(ostream& _cout, const string& s) {
    for (size_t i = 0; i < s.size(); ++i) {
        _cout << s[i];
    }
    return _cout;
}

以上是按功能块拆分的代码，每一块都有对应的中文注释解释其功能和作用。

小魏不崴脚
关注
专栏目录
[ C++ ] string类之构造，拷贝，赋值 及其模拟实现
CSDN博客
07-31 6386
C++中string类的介绍，构造函数，拷贝构造，赋值构造，析构函数原理解析
【C++】模拟实现list
C/C++领域,数据结构,linux,MySQl学习者
08-01 1119
使用C++语言模拟实现list类模板,包括list的结点类模板的实现,list迭代器类模板的实现,list类模板的实现,包含完整项目的完整运行代码.是比较适合STL初学者的学习,练习项目.
剖析【C++】——类和对象(下篇)——超详解——小白篇
小李很执着的博客
05-31 1386
类 是对某一类实体的抽象和描述。类定义了这些实体具有的属性和方法，形成了一种新的自定义类型。 对象 是类的实例，是具体的实体。通过实例化类，我们创建对象，然后可以使用这些对象来模拟现实中的实体。
（吐血整理 · 超级精华）用Java和C快速学会C++
a1071512987的博客
08-27 736
C++ 和 Java 在类的成员函数定义方面有一些重要的区别。以下是一些关键的不同点，以及相应的示例来说明这些差异。C++：成员函数可以在类内部或外部定义。内部定义的函数被视为内联函数，外部定义的函数需要使用作用域解析运算符。Java：所有成员函数都必须在类的内部定义，不能在外部定义。C++ 示例public:// 成员函数在类内部定义// 成员函数在类外部定义// 外部定义的函数需要使用作用域解析运算符 ::Box box;// 输出: Volume: 60。
C++连接CTP接口实现简单量化交易（行情、交易、k线、策略）
Struggling_Jeff的博客
10-20 4145
对于量化交易来说，量化策略和技术系统缺一不可，为了知其所以然，本文实现了一个C++连接CTP接口进行仿真交易的demo，从接收行情、下订单、数据处理到添加策略、挂载运行交易等多个环节来看一下量化交易的最简单流程，管中窥豹，一探究竟。   准备工作 交易所接口 这里使用上期所提供的CTP接口API，通过CTP可以连接交易所进行行情接收交易。下载地址：CTP下载 本文使用的win32版本的，...
超详细的springBoot学习教程,springboot学习看这篇就够了
热门推荐
lin1214000999的博客
04-12 7万+
springBoot学习 https://docs.spring.io/spring-boot/docs/2.2.6.RELEASE/reference/html/index.html (官方文档) spring boot的Maven基础配置 1.父项目springboot的版本仲裁管理依赖的版本号 <!-- 父项目springboot的版本仲裁管理依赖的版本号，后续导入就不需要导入版本号了...
初学小白C/C++语言知识难点题目总结(代码演示)
j简说Linux的博客
11-12 367
一、给定一个字符串，返回它的最长回文子串。如果存在多个答案，返回任意一个即可。字符串长度 ≤≤ 1000。 算法:（暴力枚举）O(n2)O(n2) 由于字符串长度小于1000，因此我们可以用 O(n2)O(n2) 的算法枚举所有可能的情况。 首先枚举回文串的中心 ii，然后分两种情况向两边扩展边界，直到遇到不同字符为止: 回文串长度是奇数，则依次判断 s[i−k]==s[i+k],k=1,2,3,…s[i−k]==s[i+k],k=1,2,3,… 回文串长度是偶数，则依次判断 s[i−k]==s[i+k−
【Linux线程】多线程控制（深度解析，小白一看就懂！！）
weixin_45031801的博客
08-18 1041
【线程】是进程内部的一个执行流，作为CPU运行的基本单位，对于线程的合理控制与任务的执行效率息息相关，因此掌握线程基本操作（线程控制）是很有必要的
小白学习老九君C++笔记(5)面向对象的类与继承
weixin_42592666的博客
09-19 163
S
C++新手入门：FileTranslate-master压缩包解析
文件夹里应该包含了用C++语言编写的源代码文件，这些代码是专门设计来帮助新手小白学习和理解文件翻译处理过程。通常，这样的项目可能包含文本翻译、文件处理、字符编码转换等功能。具体功能取决于该源代码的设计和...
【新手】基于C++Qt5通过调用百度翻译API制作简易翻译工具
yyy90的博客
02-08 2998
基于C++Qt5通过调用百度翻译API制作简易翻译工具 目录基于C++Qt5通过调用百度翻译API制作简易翻译工具写在前面步骤：1.注册百度翻译开放平台账号并开通翻译服务2.下载安装Qt5和QtCreator (windows)2.1下载Qt52.2安装Qt5和QtCreator2.3创建项目3.封装生成Url类3.1百度翻译文档阅读3.2编写代码4.使用Qt5制作简易图形化界面5.编写逻辑代码补充：编码转码和一些报错处理总结一下 写在前面 先看看效果图 机缘巧合我发现了百度翻译API，也看了很多大佬用
Java 反射机制 -- Java 语言反射的概述、核心类与高级应用
栗筝i的博客
06-13 4722
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于 ReflectionAPI 取得任何类的内部信息，并能直接操作任意对象的内 部属性及方法。
求职与面试(一):Java必备
Floating Cat
02-19 4万+
今天要谈的主题是关于求职.求职是在每个技术人员的生涯中都要经历多次,对于我们大部分人而言,在进入自己心仪的公司之前少不了准备工作,有一份全面细致面试题将帮助我们减少许多麻烦.在跳槽季来临之前,特地做这个系列的文章,一方面帮助自己巩固下基础,另一方面也希望帮助想要换工作的朋友.
c_cpp_properties.json文件的作用
程序员黄老师的精品课！
10-10 228
IntelliSense 是 VS Code 中内置的一个有用工具，它提供各种代码编辑功能，可帮助您更快、更高效地编写代码。例如，代码完成、参数信息、语法突出显示、代码操作（灯泡）和成员列表都是使用 IntelliSense 生成的。IntelliSense 配置存储在文件中，该文件在您的工作区中自动创建。如何产生 c_cpp_properties.json文件？这里配置一下头文件，就可以自动提示了，以OpenCV为例子。其中的属性可以在界面上改,文件会自动同步。
PyQt 的Tree Widget中拖放和点击的异常行为
weixin_44617651的博客
10-10 463
在 PyQt 的 ​​QTreeWidget​​ 中，如果你遇到 拖放 和 点击 的异常行为，可能是由于信号处理、事件拦截、拖放设置或树结构配置等问题导致的。以下是一些可能的常见问题和解决方案。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 987
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
C++的随机数操作
最新发布
lch_001的博客
10-13 115
如果不引入种子，它的随机数不是随机数，是固定的一串数字。首先想到的肯定是rand()函数，但是这个有点问题。srand()函数，产生随机的种子。引入头文件<stdlib.h>产生0-99的随机数。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 325
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值