【C++】深度解析：用 C++ 模拟实现 String 类，探索其底层实现细节

目录

了解string类

string的内存管理

VS下string的结构

​g++下string的结构

 string的模拟实现

string的构造函数

 浅拷贝

深拷贝

 string的遍历

重载 [] 下标访问

迭代器访问

reserve

resize

 增删查改

push_back()

append和+=

 insert和erase

find

substr

swap 

 流插入和流提取

getline

string其他基本功能

⭐了解string类

1. 字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
3. string 类是使用 char( 即作为它的字符类型，使用它的默认 char_traits 和分配器类型 ( 关于模板的更多信息，请参阅basic_string) 。
4. string 类是 basic_string 模板类的一个实例，它使用 char 来实例化 basic_string 模板类，并用 char_traits和allocator 作为 basic_string 的默认参数 ( 根于更多的模板信息请参考 basic_string) 。
5. 注意，这个类独立于所使用的编码来处理字节 : 如果用来处理多字节或变长字符 ( 如 UTF-8) 的序列，这个类的所有成员( 如长度或大小 ) 以及它的迭代器，将仍然按照字节 ( 而不是实际编码的字符 ) 来操作。
总结：
1. string 是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作 string 的常规操作。
3. string 在底层实际是： basic_string 模板类的别名， typedef basic_string<char, char_traits, allocator>
string;
4. 不能操作多字节或者变长字符的序列。
在 使用 string 类时，必须包含 #include 头文件以及 using namespace std ;

⭐string的内存管理

✨VS下string的结构

string总共占28个字节 ，内部结构稍微复杂一点，先是 有一个联合体，联合体用来定义 string 中字
符串的存储空间 ：
  • 当字符串长度小于16时，使用内部固定的字符数组来存放
  • 当字符串长度大于等于16时，从堆上开辟空间
union _Bxty
{ // storage for small buffer or pointer to larger onevalue_type _Buf[_BUF_SIZE];pointer _Ptr;char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;
  1. 大多数情况下字符串的长度都小于16，当string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
  2. 还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量
  3. 还有一个指针做一些其他事情。
  4. 故总共占16+4+4+4=28个字节。

✨g++下string的结构

g++ 下， string 是通过写时拷贝实现的， string对象总共占4个字节 ，内部只包含了一个指针，该指
针将来指向一块堆空间，内部包含了如下字段：
  • 空间总大小
  • 字符串有效长度
  • 引用计数
  • 指向堆空间的指针，用来存储字符串。
struct _Rep_base
{size_type _M_length;size_type _M_capacity;_Atomic_word _M_refcount;
};

 ⭐string的模拟实现

private:char* _str = nullptr;size_t _size = 0;size_t _capacity = 0;

✨string的构造函数

// 为了和标准库区分，此处使用String
class String
{
public:/*String():_str(new char[1]){*_str = '\0';}*///String(const char* str = "\0") 错误示范//String(const char* str = nullptr) 错误示范String(const char* str = "")//默认包含 \0{// 构造String类对象时，如果传递nullptr指针，可以认为程序非法if (nullptr == str){assert(false);return;}_str = new char[strlen(str) + 1];strcpy(_str, str);}~String(){if (_str){delete[] _str;_str = nullptr;}}
private:char* _str;
};
// 测试
void TestString()
{String s1("hello bit!!!");String s2(s1);
}

 

上述 String 类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用 s1 构 造 s2 时，编译器会调用默认的拷贝构造。最终导致的问题是， s1 、 s2 共用同一块内存空间，在释放时同一块 空间被释放多次而引起程序崩溃 ，这种拷贝方式，称为 浅拷贝 。

 📖浅拷贝

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来 。如果 对象中管理资源 ，最后就会 导致多个对象共 享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为 还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
举个例子，如果一个家庭里面有两个孩子，但是父母只给他们买了一个玩具，如果两个孩子都愿意玩这一个玩具，那就相安无事，否则就会鸡飞狗跳。
要解决这个问题，就可以直接给他们一人买一个玩具，这样各自安逸。
所以，要想解决浅拷贝的问题，可以使用深拷贝的方法， 每个对象都有一份独立的资源，不要和其他对象共享 。

📖深拷贝

如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

 ✨string的遍历

📖重载 [] 下标访问

char& operator[](size_t pos)//可读可写
{assert(pos < _size);return _str[pos];
}
//重载一个const
const char& operator[](size_t pos) const//只读
{assert(pos < _size);return _str[pos];
}

首先访问之前需要判断pos是否再合法访问之内，即小于等于size，然后直接返回字符串数组中对应的元素。由于存在const对象和非const对象，所以需要写两个重载版本。

📖迭代器访问

//迭代器typedef char* iterator;typedef const char* const_iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}const_iterator begin()const{return _str;}const_iterator end()const{return _str + _size;}

 其实底层就是指针，所以直接返回对应的地址就可以了。

✨reserve

void reserve(size_t n)
{if (n > _capacity){char* tmp = new char[n+1];strcpy(tmp, _str);//释放旧空间，指向新空间delete[] _str;_str = tmp;//修改capacity，不用修改size_capacity = n;}
}

reserve是提前预留部分空间，它接收的空间大小不能比本来就有的容量小，如果n合法，则需要将原数组从旧空间移向一块更大的新空间，并释放掉旧空间。

✨resize

void resize(size_t n,char ch='\0')
{if (n <= _size){_str[n] = '\0';_size = n;}else{reserve(n);for (int i = _size; i < n; i++){_str[i] = ch;}_str[n] = '\0';_size = n;}
}

resize是设置字符串的大小，如果n比字符串原来的大小小，则会发生截断；如果比原来的大小大，则会reserve一块n大小的空间。

 ✨增删查改

📖push_back()

void push_back(char ch)
{//扩容2倍if (_size == _capacity){reserve(_capacity==0 ? 4 : 2 * _capacity);}_str[_size] = ch;_size++;_str[_size] = '\0';
}

直接尾插就可以，需要先判断空间是否足够，最后更新size的大小。

📖append和+=

void append(const char* str)
{//扩容//根据追加的字符串的长度扩容size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}strcpy(_str + _size, str);_size += len;
}
//  +=  
string& operator+=(char ch)
{push_back(ch);return *this;
} 
string& operator+=(const char* str)
{append(str);return *this;
}
string& operator+=(const string s)
{append(s._str);return *this;
}

append和+=都是在字符串的尾部追加字符或者字符串，需要先判断容量是否足够，不够则需要扩容， 根据追加的字符串的长度扩容。

 📖nsert和erase

对于insert，0位置的插入可能产生问题，end是int类型，pos是size_t类型，end变成-1与pos比较时会发生整型提升，所以pos需要先进行强制类型转换；也可以使用另一种解决方法，将end的初始值赋值为size+1，每次使用这种方法后移字符串 _str[end] = _str[end - 1];，则end最后不会变成-1。

//在pos之前插入
//插入字符
void insert(size_t pos,char ch)
{assert(pos <= _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}//int end = _size;0位置的插入可能产生问题，end变成-1与pos比较时会发生整型提升，所以pos需要先进行强制类型转换//while (end >= (int)pos)//{//	_str[end+1] = _str[end];//	end--;//}//第二种解决方法int end = _size + 1;while (end > pos){_str[end] = _str[end - 1];end--;}_str[pos] = ch;_size++;
}
//在pos之前插入
//插入字符串
void insert(size_t pos,const char* str)
{assert(pos <= _size);int len = strlen(str);if (_size +len > _capacity){reserve(_size + len+1);}//int end = _size;0位置的插入可能产生问题，end变成-1与pos比较时会发生整型提升，所以pos需要先进行强制类型转换//while (end >= (int)pos)//{//	_str[end+1] = _str[end];//	end--;//}//第二种解决方法//在pos之前插入int end = _size + len;//pos 1 2 endwhile (end > pos+len-1){_str[end] = _str[end - len];end--;}strncpy(_str + pos,str,len);_size+=len;
}
//释放删除
void erase(size_t pos, size_t len = npos)
{assert(pos < _size);// pos+len 存在溢出风险//if (len == npos || pos + len >= _size)if (len == npos ||len >= _size-pos){_str[pos] = '\0';_size = pos;}else{strcpy(_str + pos, _str + pos + len);_size -= len;}
}

对于erase，需要根据传递的参数的大小来判断需要删除多少个字符。

📖find

//寻找匹配
size_t find(char ch,size_t pos = 0) const
{for (size_t i = pos; i < _size; i++){if (_str[i] == ch)return i;}return npos;
}
size_t find(const char* sub, size_t pos = 0) const
{assert(pos <= _size);const char* p=strstr(_str+pos, sub);if (p){return p - _str;}elsereturn npos;
}

实现方法比较简单，就是普通的暴力查找。 

📖substr

截取子串，需要注意len的大小。

        string substr(size_t pos = 0, size_t len = npos){string sub;if (len == npos|| len >= _size - pos){for (size_t i = pos; i < _size; i++){sub += _str[i];}}else{for (size_t i = pos; i < pos + len; i++){sub += _str[i];}}return sub;}

✨swap 

众所周知，C++算法库里面存在swap这个函数模板，但是为什么string内部自己也有一个swap呢？

如果用std::swap交换两个string对象，将会发生1次构造和2次赋值，也就是三次深拷贝；

而string内部的swap仅仅只交换成员，代价较小。

//交换
void swap(string& s)
{std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);
}

 为了符合算法库里面swap的用法，可以再将swap重载成全局函数。

	void swap(string& x, string& y){x.swap(y);}

✨ 流插入和流提取

//重载成全局是为了调整顺序//流插入ostream& operator<<(ostream& out, const string& s){//这里不需要写成友元函数，因为不需要直接访问私有成员for (auto ch:s){cout << ch;}return out;}//流提取//C++ 流插入，流提取可以支持自定义类型使用istream& operator>>(istream& in, string& s){s.clear();char ch;char buff[128];//in >> ch;//默认把空格当作分隔符、换行，不读取ch = in.get();//C++中读取一个字符size_t i = 0;while (ch != ' ' && ch != '\n'){buff[i++] = ch;if (i == 127){buff[127] = '\0';s += buff;i = 0;}//s += ch;//重复+=，会重复扩容，消耗较大ch = in.get();}if (i > 0){buff[i] = '\0';s += buff;}return in;}

因为在这里不需要直接访问类的私有成员，所以流插入和流提取可以不用重载成string类的友元函数。

对于流提取，如果频繁的尾插，会造成频繁扩容。而且C++的扩容和C语言的扩容不一样，C++使用new不能原地扩容，只能异地扩容，异地扩容就会导致新空间的开辟、数据的拷贝、旧空间释放。为了防止频繁扩容，我们可以创建一个可以存储128字节的数组，作为缓冲，如果数组满了，则将这个字符数组追加到s上，如果没慢，但是遇到空格或者换行了也需要追加。

另外由于C++的标准输入流默认把空格和换行当作分隔符，不读取，所以这里要用in.get()来接收字符。

✨getline

基本上可以直接复用流提取的代码。

//读取空格istream& getline(istream& in, string& s){s.clear();char ch;//in >> ch;//默认把空格当作分隔符、换行，不读取ch = in.get();//C++中读取一个字符while ( ch != '\n'){s += ch;ch = in.get();}return in;}

✨string其他基本功能

        size_t size() const{return _size;}size_t capacity() const{return _capacity;}void clear(){_size = 0;_str[_size] = '\0';}

重载运算符，要写成全局的函数。

bool operator==(const string& a ,const string& b){int ret = strcmp(a.c_str(), b.c_str());return ret == 0;}bool operator<(const string& a, const string& b){int ret = strcmp(a.c_str(), b.c_str());return ret < 0;}bool operator<=(const string& s1, const string& s2){return  (s1 < s2) || (s1 == s2);}bool operator>(const string& s1, const string& s2){return  !(s1 <= s2);}bool operator>=(const string& s1, const string& s2){return  !(s1 < s2);}bool operator!=(const string& s1, const string& s2){return  !(s1 == s2);}

____________________

⭐感谢你的阅读，希望本文能够对你有所帮助。如果你喜欢我的内容，记得点赞关注收藏我的博客，我会继续分享更多的内容。⭐

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

自然资源-“十四五”规划引领，审批智慧化提升-值得学习

自然资源-“十四五”规划引领，审批智慧化提升-值得学习

自然资源-“十四五”规划引领&#xff0c;审批智慧化提升-值得学习 2022年1月12日&#xff0c;国务院正式印发了《“十四五”数字经济发展规划》&#xff08;国发〔2021〕29号&#xff09;&#xff0c;从八个方面对“十四五”期间我国数字经济发展做出总体部署。其中第五点要求…
阅读更多...
SpringBoot报空指针错：java.lang.NullPointerException

SpringBoot报空指针错：java.lang.NullPointerException

虽然报空指针错误的原因可能有很多种&#xff0c;但是我还是写上我的报错原因&#xff0c;以此与各位共勉~ 在这里提前说一句&#xff0c;AI虽然强大&#xff0c;但是还是要谨慎使用啊(血的教训)~ 这里先截图我错误的地方&#xff1a; 前端能成功传进来值&#xff0c;后台控制…
阅读更多...
【运维自动化-配置平台】如何自动应用主机属性

【运维自动化-配置平台】如何自动应用主机属性

主要用于配置主机属性的自动应用。当主机发生模块转移或模块新加入主机时&#xff0c;会根据目标模块配置的策略自动触发修改主机属性&#xff0c;比如主机负责人、主机状态。主机属性自动应用顾名思义是应用到主机上&#xff0c;而主机是必须在模块下的&#xff0c;所以有两种…
阅读更多...
花趣短视频源码淘宝客系统全开源版带直播带货带自营商城流量主小游戏功能介绍

花趣短视频源码淘宝客系统全开源版带直播带货带自营商城流量主小游戏功能介绍

1、首页仿抖音短视频 &#xff0c;关注 &#xff0c;我的 本地 直播 可发布短视频 可录制上传 2、商城页面 广告位、淘口令识别、微信登录、淘宝登录、淘宝返佣、拼多多返佣、京东返佣、唯品会返佣、热销榜、聚划算、天猫超市、9.9包邮、品牌特卖、新人攻略 、小米有品、优惠加…
阅读更多...
盘他系列——oj！！！

盘他系列——oj！！！

1.Openjudge 网站: OpenJudge 2.洛谷 网站: 首页 - 洛谷 | 计算机科学教育新生态 3.环球OJ 网站: QOJ - QOJ.ac 4. 北京大学 OJ:Welcome To PKU JudgeOnline 5.自由OJ 网站: https://loj.ac/ 6.炼码 网站:LintCode 炼码 8.力扣 网站: 力扣 9.晴练网首页 - 晴练网
阅读更多...
在线视频教育平台，基于 SpringBoot+Vue+MySQL 开发的前后端分离的在线视频教育平台设计实现

在线视频教育平台，基于 SpringBoot+Vue+MySQL 开发的前后端分离的在线视频教育平台设计实现

目录 一. 前言 二. 功能模块 2.1. 用户功能模块 2.2. 管理员功能模块 2.3. 教师功能模块 2.4. 前台首页功能模块 三. 部分代码实现 四. 源码下载 一. 前言 随着科学技术的飞速发展&#xff0c;各行各业都在努力与现代先进技术接轨&#xff0c;通过科技手段提高自身的优…
阅读更多...
部分树上问题及图的联通性（图论学习总结部分内容）

部分树上问题及图的联通性（图论学习总结部分内容）

文章目录 前言三、部分树上问题及图的联通性最小生成树知识点例题 e g 1 : eg1: eg1: 走廊泼水节&#xff08;克鲁斯卡尔思想的灵活运用&#xff09; e g 2 &#xff1a; eg2&#xff1a; eg2&#xff1a; B-Picnic Planning e g 3 eg3 eg3&#xff1a;L - Classic Problem&…
阅读更多...
探索ISP静态：网络连接的稳定基石

探索ISP静态：网络连接的稳定基石

在数字化时代的浪潮中&#xff0c;互联网已成为我们生活、工作、学习不可或缺的一部分。而网络连接的质量&#xff0c;直接决定了我们在线体验的好坏。在众多网络连接技术中&#xff0c;“ISP静态”作为一种稳定、可靠的网络连接方式&#xff0c;越来越受到广大用户的青睐。本文…
阅读更多...
微服务熔断降级

微服务熔断降级

什么是熔断降级 微服务中难免存在服务之间的远程调用&#xff0c;比如&#xff1a;内容管理服务远程调用媒资服务的上传文件接口&#xff0c;当微服务运行不正常会导致无法正常调用微服务&#xff0c;此时会出现异常&#xff0c;如果这种异常不去处理可能导致雪崩效应。 微服…
阅读更多...
redis原生命令及项目使用

redis原生命令及项目使用

主动更新策略 缓存问题及解决 布隆过滤出现哈希冲突解决方案： 选择合适的哈希函数：布隆过滤器的性能和哈希函数的选择密切相关。选择高效、低碰撞率的哈希函数可以降低误判率。通常使用的哈希函数有 MurmurHash、FNV 等。 合理设置过滤器大小：过滤器的大小（位数组的大小）…
阅读更多...
资料同化 | 搭建docker环境-1

资料同化 | 搭建docker环境-1

Community Gridpoint Statistical Interpolation (GSI) system DTC 是一个分布式设施&#xff0c;NWP 社区可以在这里测试和评估用于研究和操作的新模型和技术。 DTC的目标包括&#xff1a; 链接研究和操作社区 研究成果转化为实际操作的速度 加快改善天气预报 开发和测试有…
阅读更多...
C语言易错提醒选择题精选

C语言易错提醒选择题精选

Ⅰ 易错题 1.设有double p;&#xff0c;为变量p声明一个引用名称rp,则定义语句为 double& rpp; 2.已知‘A’一‘Z’的ASCII码为65—90&#xff0c;当执行“char ch14*52&#xff1b;cout<<ch<<endl;”语句序列后得到的输出结H &#xff0c;72对应ASCII码中…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023