【C++】string的深入学习与模拟实现

Dear 丶 2024-04-26 10:59 48阅读 0赞

![在这里插入图片描述][6ac7346dc5944908b5dd227e55fab217.gif_pic_center]

> ?write in front?  
> ?所属专栏：[初阶数据结构][Link 1]  
> ?️博客主页：[睿睿的博客主页][Link 2]  
> ?️代码仓库：?[VS2022\_C语言仓库][VS2022_C]  
> ?您的点赞、关注、收藏、评论，是对我最大的激励和支持！！！  
> **关注我，关注我，关注我**，你们将会看到更多的优质内容！！

![在这里插入图片描述][85d8f838a7524c8bb8bed80b7ac059c1.gif_pic_center]

#### 文章目录 ####

*  前言
 *  一.string的成员变量：
 *  二.string的成员函数：
 *   *  1.构造函数：
     *  2.析构函数：
     *  3.赋值运算符重载：
     *  4.对于深拷贝浅拷贝问题的说明与解决方案：
 *  三.string的迭代器
 *  四.string的容量操作
 *  五.string的元素访问
 *  六.string的修饰操作：
 *   *  push\_back插入字符：
     *  append插入字符串：
     *  \+=重载：
     *  insert插入数据：
     *  erase删除数据：
 *  七.string的字符串操作
 *   *  find查找字符位置：
     *  substr返回所寻子串
     *  c\_str返回字符串数组
 *  八.string的非成员函数重载
 *   *  比较运算符重载：
     *  流输出运算符：
     *  流输入运算符：
 *  总结

## 前言 ##

在C++中，字符串是一种非常常见的数据类型，用于存储和操作文本信息。标准库中的string类提供了强大的字符串操作功能，但是了解其背后的实现原理对于深入理解和灵活运用字符串类至关重要。在本篇博客中，我们将一起学习标准库中string类的实现原理，并模拟实现自己的string类。

## 一.string的成员变量： ##

![在这里插入图片描述][5fac553ff4c64539ba8787559463cd50.png]  
在标准库里面的string的成员变量看起来很复杂，但是其实本质就是一个顺序表,下面是对于该部分的模拟实现：

namespace zxr
    {
        
    	class bit
    	{
        
    	private:
    		size_t _size;
    		size_t _capacity;
    		char* _str;
    	};
    };

在这里我们要注意的是不同编译器下的成员变量会有微微的不同，比如vs下面，当成员长度小于16时，就会通过一个16个字节大小的数组来存储，当大于16时才是用堆来存储。  
![在这里插入图片描述][b33d2885026449bdbacb2cbd6cfe92a5.png]

## 二.string的成员函数： ##

![在这里插入图片描述][39c199e678b34c51bad97aabeec34d11.png]

### 1.构造函数： ###

构造函数有很多的重载：  
![在这里插入图片描述][3cbc0fb4052b443abd729b04ad607f3e.png]  
其中最常见的是如下：

void Teststring()
    {
        
     string s1; // 构造空的string类对象s1
     string s2("hello bit"); // 用C格式字符串构造string类对象s2
     string s3(s2); // 拷贝构造s3
    }

下面我们来模拟实现一个`构造函数`：

string(const char* str = "")
    	{
        
    			_size = strlen(str);
    			_capacity = _size;
    			_str = new char[_capacity + 1];
    			strcpy(_str, str);
    	}

这一个构造函数是一个默认的构造函数，将传进来的c字符串存入顺序表中，并且没有初始化的string类也能够进行初始化。

有了构造函数还是远远不够的，对于复制构造函数，如果我们不通过自己写的深拷贝而调用编译器自己的浅拷贝，在析构的时候就会析构两次，产生错误：  
![在这里插入图片描述][230ae584f0a74411ba819b17cac5c05d.png]

所以我们要自己实现`复制构造函数`：

string(const string& s)
    		{
        
    			_str = new char[s._capacity + 1];
    			//strcpy(_str, s._str);
    			memcpy(_str, s._str, s._size + 1);
    			_size = s._size;
    			_capacity = s._capacity;
    		}

### 2.析构函数： ###

![在这里插入图片描述][ffd1fee546924acbac0595bf35d687b1.png]

~string()
    		{
        
    			delete[] _str;
    			_str = nullptr;
    			_size = _capacity = 0;
    		}

### 3.赋值运算符重载： ###

![在这里插入图片描述][984a1475126d4ddd825470ddb1f8a74a.png]

对于赋值运算符重载有两种方法实现：

*  **常规方法：**

string& operator=(const string& s)
    		{
        
    			if (this != &s)
    			{
        
    				char* tmp = new char[s._capacity + 1];
    				memcpy(tmp, s._str, s._size+1);
    				delete[] _str;
    				_str = tmp;
    
    				_size = s._size;
    				_capacity = s._capacity;
    			}
    
    			return *this;
    		}

*  简单方法：

void swap(string& s)
    		{
        
    			std::swap(_str, s._str);
    			std::swap(_size, s._size);
    			std::swap(_capacity, s._capacity);
    		}
    string& operator=(string tmp)
    		{
        
    			swap(tmp);
    			return *this;
    		}

在这里我们调用了库里面的swap函数，注意看，我们的tmp是一个形参，**并没有用引用**（很重要的一点），在出函数以后就会调用析构函数自动销毁，所以我们就可以放心的使用swap函数对其进行操作啦。

### 4.对于深拷贝浅拷贝问题的说明与解决方案： ###

我们之所以要深拷贝，原因就是对于在堆上面开辟的空间，如果我们单纯使用**浅拷贝就会产生下面的问题**：

1.  **析构两次**
2.  **一个对象修改会影响另一个**

在实际的编译器里会通过`引用计数`的方式来解决：

![在这里插入图片描述][c6977f61f51e4a88bb38d7305c6d9d4f.png]  
大概过程如下：

*  构造函数中创建类的新对象时，初始化引用计数为1；
 *  拷贝构造函数复制指针，并使相应的引用计数增加1；
 *  赋值操作减少左操作数所值对象的引用计数，增加右操作数所指对象的引用计数；
 *  析构函数使引用计数减少1，并且当引用计数为1时，释放指针说指向的对象；

简单的说，就是对象实例化之后，如果出现了复制构造，那么这个类的计数就会+1，如果这个对象要析构，先检查引用计数的次数是否等于1，不等于1就不释放这个空间，让引用计数-1，如果等于1在析构。

对于要修改的对象，我们就要通过深拷贝构造出一个新对象，然后将引用计数-1就可以了！  
![在这里插入图片描述][4675e13cfd9b4b24ba3af778a124a8d5.png]  
gcc测试如下：  
![在这里插入图片描述][2b12e56ca09e4e61920e89f970337c29.png]

## 三.string的迭代器 ##

对于string类型，其迭代器就是指针。  
![在这里插入图片描述][d83fbf67da784c20bf63cd8fbbef6c7d.png]  
所以我们可以通过重命名的方式来写出迭代器的类型：

typedef char* iterator;
    		typedef const char* const_iterator;

下面我们模拟最简单`begin`和`end`  
![在这里插入图片描述][9e094ebe78824bec903059e9b3a0b214.png]  
对于`begin()`，模拟如下：

iterator begin()
    		{
        
    			return _str;
    		}
    		const_iterator begin() const
    		{
        
    			return _str;
    		}

对于`end()`，模拟如下：  
![在这里插入图片描述][e32ee655f36f478587ef1c8b05229598.png]

iterator end()
    		{
        
    			return _str + _size;
    		}
    
    
    		const_iterator end() const
    		{
        
    			return _str + _size;
    		}

一个是只读一个是可读可写，这里就不必多说。

在就是迭代器的使用，**其实当我们写好了迭代器，我们auto的语法糖也可以直接用了**：

//zxr::string::const_iterator cit = s3.begin();
    	auto cit = s3.begin();
    	while (cit != s3.end())
    	{
        
    		//*cit += 1;
    
    		cout << *cit << " ";
    		++cit;
    	}
    	cout << endl;
    
    	zxr::string::iterator it = s1.begin();
    	while (it != s1.end())
    	{
        
    		*it += 1;
    
    		cout << *it << " ";
    		++it;
    	}
    	cout << endl;
    
    	for (auto ch : s1)
    	{
        
    		cout << ch << " ";
    	}
    	cout << endl;

其实auto的底层也就是通过迭代器来遍历string.

## 四.string的容量操作 ##

![6][]  
这几个容量操作的函数非常好模拟实现，我们就说几个注意事项就可以了。

返回数组大小size
    		size_t size() const
    		{
        
    			return _size;
    		}
    		
    	对string对象预留空间，注意：是空间，size大小没有改变
    			void reserve(size_t n)
    		{
        
    			if (n > _capacity)
    			{
        
    				cout << "reserve()->" << n << endl;
    
    				char* tmp = new char[n + 1];
    				//strcpy(tmp, _str);
    				memcpy(tmp, _str, _size+1);
    
    				delete[] _str;
    				_str = tmp;
    				_capacity = n;
    			}
    		}
    		
    	对string对象预留空间并将size也增加了，是上面的升级版，size和capacity大小都改变了
    		void resize(size_t n, char ch = '\0')
    		{
        
    			if (n < _size)
    			{
        
    				_size = n;
    				_str[_size] = '\0';
    			}
    			else
    			{
        
    				reserve(n);
    
    				for (size_t i = _size; i < n; i++)
    				{
        
    					_str[i] = ch;
    				}
    
    				_size = n;
    				_str[_size] = '\0';
    			}
    		}
    		
    	将string中有效字符清空，不改变底层空间大小。
    		void clear()
    		{
        
    			_str[0] = '\0';
    			_size = 0;
    		}

**注意事项：**

1.  size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2.  clear()只是将string中有效字符清空，不改变底层空间大小。
3.  resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4.  reserve：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。

## 五.string的元素访问 ##

![在这里插入图片描述][86b3f21cf5c64b85ba78176f4265ab13.png]  
这里元素访问，我们最熟悉的就是`[]`  
![在这里插入图片描述][c5802969a63f473984653ba8d9b8b293.png]  
模拟实现非常简单，不必多说：

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

## 六.string的修饰操作： ##

![在这里插入图片描述][ce470921cd5e4f14a693672e59771d47.png]  
这里的模拟实现就很需要大家的基本功了。

### push\_back插入字符： ###

![在这里插入图片描述][94ee995a855c43c6b68714d84fa8c9c3.png]

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

### append插入字符串： ###

![在这里插入图片描述][165b20ef11cf42d0a4b5bc97e01a4ffa.png]

void append(const char* str)
    		{
        
    			size_t len = strlen(str);
    			if (_size + len > _capacity)
    			{
        
    				// 至少扩容到_size + len
    				reserve(_size+len);
    			}
    
    			//strcpy(_str + _size, str);
    			memcpy(_str + _size, str, len+1);
    
    			_size += len;
    		}

### \+=重载： ###

![在这里插入图片描述][3c81d8c4c22045349c7a182575d1af23.png]

string& operator+=(char ch)
    		{
        
    			push_back(ch);
    			return *this;
    		}
    
    		string& operator+=(const char* str)
    		{
        
    			append(str);
    			return *this;
    		}

### insert插入数据： ###

![在这里插入图片描述][34e87e8b19ea4ac0919b6087bee5d6e7.png]

void insert(size_t pos, size_t n, char ch)
    		{
        
    			assert(pos <= _size);
    
    			if (_size +n > _capacity)
    			{
        
    				// 至少扩容到_size + len
    				reserve(_size + n);
    			}
    			// 添加注释最好
    			// 防止越界
    			size_t end = _size;
    			while (end >= pos && end != npos)
    			{
        
    				_str[end + n] = _str[end];
    				--end;
    			}
    
    			for (size_t i = 0; i < n; i++)
    			{
        
    				_str[pos + i] = ch;
    			}
    
    			_size += n;
    		}
    
    		void insert(size_t pos, const char* str)
    		{
        
    			assert(pos <= _size);
    
    			size_t len = strlen(str);
    			if (_size + len > _capacity)
    			{
        
    				// 至少扩容到_size + len
    				reserve(_size + len);
    			}
    
    			// 添加注释最好
    			//防止越界
    			size_t end = _size;
    			while (end >= pos && end != npos)
    			{
        
    				_str[end + len] = _str[end];
    				--end;
    			}
    
    			for (size_t i = 0; i < len; i++)
    			{
        
    				_str[pos + i] = str[i];
    			}
    
    			_size += len;
    		}

### erase删除数据： ###

![在这里插入图片描述][36365269b4d34f349a2ea35a3f14e9f9.png]

void erase(size_t pos, size_t len = npos)
    		{
        
    			assert(pos <= _size);
    
    			if (len == npos || pos + len >= _size)
    			{
        
    				//_str[pos] = '\0';
    				_size = pos;
    				_str[_size] = '\0';
    			}
    			else
    			{
        
    				size_t end = pos + len;
    				while (end <= _size)
    				{
        
    					_str[pos++] = _str[end++];
    				}
    				_size -= len;
    			}
    		}

## 七.string的字符串操作 ##

![在这里插入图片描述][be19304523bc4d1983b9cca3dccd42f9.png]

### find查找字符位置： ###

返回该字符的下标

size_t find(char ch, size_t pos = 0)
    		{
        
    			assert(pos < _size);
    
    			for (size_t i = pos; i < _size; i++)
    			{
        
    				if (_str[i] == ch)
    				{
        
    					return i;
    				}
    			}
    
    			return npos;
    		}
    
    		size_t find(const char* str , size_t pos = 0)
    		{
        
    			assert(pos < _size);
    
    			const char* ptr = strstr(_str + pos, str);
    			if (ptr)
    			{
        
    				return ptr - _str;
    			}
    			else
    			{
        
    				return npos;
    			}
    		}

### substr返回所寻子串 ###

string substr(size_t pos = 0, size_t len = npos)
    		{
        
    			assert(pos < _size);
    
    			size_t n = len;
    			if (len == npos || pos + len > _size)
    			{
        
    				n = _size - pos;
    			}
    
    			string tmp;
    			tmp.reserve(n);
    			for (size_t i = pos; i < pos + n; i++)
    			{
        
    				tmp += _str[i];
    			}
    			return tmp;
    		}

### c\_str返回字符串数组 ###

返回字符串数组的时候使用，适用于printf打印。

const char* c_str() const
    		{
        
    			return _str;
    		}

## 八.string的非成员函数重载 ##

![在这里插入图片描述][8a31090a0df04af89cb654988080c90c.png]

### 比较运算符重载： ###

bool operator<(const string& s) const
    		{
        
    			int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
    			return ret == 0 ? _size < s._size : ret < 0;
    		}
    
    		bool operator==(const string& s) const
    		{
        
    			return _size == s._size 
    				&& memcmp(_str, s._str, _size) == 0;
    		}
    
    		bool operator<=(const string& s) const
    		{
        
    			return *this < s || *this == s;
    		}
    
    		bool operator>(const string& s) const
    		{
        
    			return !(*this <= s);
    		}
    
    		bool operator>=(const string& s) const
    		{
        
    			return !(*this < s);
    		}
    
    		bool operator!=(const string& s) const
    		{
        
    			return !(*this == s);
    		}

### 流输出运算符： ###

![在这里插入图片描述][b0dfcee0a3bb4b4596e465c08815fc54.png]

ostream反拷贝，所以用引用。
    ostream& operator<<(ostream& out, const string& s)
    	{
        
    		/*for (size_t i = 0; i < s.size(); i++)
    		{
    			out << s[i];
    		}*/
    
    		for (auto ch : s)
    		{
        
    			out << ch;
    		}
    
    		return out;
    	}

在这里我们可以明显看出在打印string对象时和字符串数组的区别，字符串数组打印时以’\\0’为结束，而string对象以迭代器的end结束，所以string里面如果存在’\\0’也没关系。**这就是为什么上面的拷贝要用memcpy而不是strcpy！**

### 流输入运算符： ###

![在这里插入图片描述][464f87b24fa947508d780b4a9c009a26.png]

istream& operator>>(istream& in, string& s)
    	{
        
    		s.clear();
    		//处理掉之前对象里的内容
    		char ch = in.get();
    		// 处理前缓冲区前面的空格或者换行
    		while (ch == ' ' || ch == '\n')
    		{
        
    			ch = in.get();
    		}
    
    		//in >> ch;
    		char buff[128];
    		int i = 0;
    
    		while (ch != ' ' && ch != '\n')
    		{
        
    			buff[i++] = ch;
    			if (i == 127)
    			{
        
    				buff[i] = '\0';
    				s += buff;
    				i = 0;
    			}
    
    			//in >> ch;
    			ch = in.get();
    		}
    
    		if (i != 0)
    		{
        
    			buff[i] = '\0';
    			s += buff;
    		}
    
    		return in;
    	}
    };

这里由于我们不知道我们要输入多少字符，不能预先开好空间，所以只能一个字符一个字符的输入。但是我们也不能通过`cin>>ch`来输入字符，因为cin只有读到**空格**或**换行符**的时候才能读取成功一个，对于一段完整的字符串，我们要使用该类里面的另一个函数[`get()`][get]来读取才行。该函数输入一个字符就读取，符合该功能。  
![在这里插入图片描述][4f44e905a264448bb27492c8c2033f5e.png]  
对于中间开的buff数组，只是为了增加效率，不然每输入一个字符就扩容一次，效率低下。

## 总结 ##

这就是string类的深入学习与模拟实现啦！如果在使用方面还有上面疑惑的话可以去官网查看或者私信我[c++使用手册][c]，想看模拟实现相关代码的可以去我的gitee[string模拟实现][string]上看！如果本篇文章有上面错误的话请私信我哟！

更新不易，辛苦各位小伙伴们动动小手，?三连走一走?? ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！

参考文献：https://legacy.cplusplus.com/

> **专栏订阅：**  
> [每日一题][Link 3]  
> [C语言学习][C]  
> [算法][Link 4]  
> [智力题][Link 5]  
> [初阶数据结构][Link 1]  
> [Linux学习][Linux]  
> [C++学习][C 1]  
> 更新不易，辛苦各位小伙伴们动动小手，?三连走一走?? ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！

![在这里插入图片描述][55270e2552774a17a711aa978da84193.gif_pic_center]

[6ac7346dc5944908b5dd227e55fab217.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/2a5672db56b9469ab5cdcd703ed23521.gif
[Link 1]: https://blog.csdn.net/qq_74310471/category_12216969.html?spm=1001.2014.3001.5482
[Link 2]: https://blog.csdn.net/qq_74310471?spm=1000.2115.3001.5343
[VS2022_C]: https://gitee.com/zhangxuruihhhh/c-language-learning
[85d8f838a7524c8bb8bed80b7ac059c1.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/270677f8819144bf9eb45bc7cf437bab.gif
[5fac553ff4c64539ba8787559463cd50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/5d50136eb52a412886b306ebba801010.png
[b33d2885026449bdbacb2cbd6cfe92a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0031f5483cfa4e3199abd42897a05f8e.png
[39c199e678b34c51bad97aabeec34d11.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/bd1d33755c96406cb1c6dc3de8da1b0f.png
[3cbc0fb4052b443abd729b04ad607f3e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/6f4444f3fcbf429f8ddc9705c1763773.png
[230ae584f0a74411ba819b17cac5c05d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/6e031aa3c86043b0b5966c9474ad8d09.png
[ffd1fee546924acbac0595bf35d687b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/cfd89a2f6694471a910f0c1d5e924119.png
[984a1475126d4ddd825470ddb1f8a74a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/2068cbc9998844ccbc3575441a90a6d1.png
[c6977f61f51e4a88bb38d7305c6d9d4f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/923e841e870f43a3b3a722a37681e38c.png
[4675e13cfd9b4b24ba3af778a124a8d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/82067ea560f147ba87f0652b5bedc8ae.png
[2b12e56ca09e4e61920e89f970337c29.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/f0c9ae639f704cafa032e4da48f03fd2.png
[d83fbf67da784c20bf63cd8fbbef6c7d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1206ad1187af4ddfbf528b846b65ad4c.png
[9e094ebe78824bec903059e9b3a0b214.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3b1e2f4b917b41778ffaf19d676e8a61.png
[e32ee655f36f478587ef1c8b05229598.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/f7f61bcf682246d5af7a61933439c941.png
[6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1f2f7e0dc1e74ec0a2e763eb06ad1b26.png
[86b3f21cf5c64b85ba78176f4265ab13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/b138d4ffce3145d28be045fcc109cfde.png
[c5802969a63f473984653ba8d9b8b293.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/53e814d5b4a4438f86e88a690a414a47.png
[ce470921cd5e4f14a693672e59771d47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7786d320afff42d99fc0cfd28178a84a.png
[94ee995a855c43c6b68714d84fa8c9c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/d0aafbfb698d4187a1486ec3c9cee74b.png
[165b20ef11cf42d0a4b5bc97e01a4ffa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1bad643c64514746b58b3e77090c1e22.png
[3c81d8c4c22045349c7a182575d1af23.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/ce58f5c559f447ac8a28aa496d4573c4.png
[34e87e8b19ea4ac0919b6087bee5d6e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c644e9e56b854b4e93432ab11a3c5cb2.png
[36365269b4d34f349a2ea35a3f14e9f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0e65790048004aa0b9df9fcd2818e713.png
[be19304523bc4d1983b9cca3dccd42f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/4afb23eff69b43ef89b5e482eaf89acf.png
[8a31090a0df04af89cb654988080c90c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c820d9974ff843d38d082574b36899c6.png
[b0dfcee0a3bb4b4596e465c08815fc54.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0b22ab6087d1463884d79fbe5c12e3e4.png
[464f87b24fa947508d780b4a9c009a26.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/9ad7795a9911490dbea61be29764b5fa.png
[get]: https://legacy.cplusplus.com/reference/istream/istream/get/
[4f44e905a264448bb27492c8c2033f5e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/be88bf49b90c4b9e815f69973e921ad4.png
[c]: https://legacy.cplusplus.com/
[string]: https://gitee.com/zhangxuruihhhh/data-structure/tree/master/string%E6%A8%A1%E6%8B%9F%E5%AE%9E%E7%8E%B0/string%E6%A8%A1%E6%8B%9F%E5%AE%9E%E7%8E%B0
[Link 3]: https://blog.csdn.net/qq_74310471/category_12166401.html?spm=1001.2014.3001.5482
[C]: https://blog.csdn.net/qq_74310471/category_12157207.html?spm=1001.2014.3001.5482
[Link 4]: https://blog.csdn.net/qq_74310471/category_12144452.html?spm=1001.2014.3001.5482
[Link 5]: https://blog.csdn.net/qq_74310471/category_12166402.html
[Linux]: https://blog.csdn.net/qq_74310471/category_12291120.html
[C 1]: https://blog.csdn.net/qq_74310471/category_12289978.html
[55270e2552774a17a711aa978da84193.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/5348db54294d497487d70cc95b44f742.gif