【C++】string的使用及其模拟实现

曾经终败给现在 2024-04-27 07:30 59阅读 0赞

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

*  1. STL的介绍
 *   *  1.1 STL的六大组件
     *  1.2 STL的版本
     *  1.3 STL的缺陷
 *  2. string的使用
 *   *  2.1 为什么要学习string类？
     *  2.2 常见构造
     *  2.3 Iterator迭代器
     *  2.4 Capacity
     *  2.5 Modifiers
     *  2.6 String operations
 *  3. string的模拟实现
 *   *  3.1 构造函数
     *  3.2 拷贝构造函数
     *  3.3 赋值运算符重载和析构函数
     *  3.4 常用接口(c\_str、\[ \]、迭代器、size和capacity)
     *  3.5 关系运算符的重载
     *  3.6 插入、删除和容量操作(reserve和resize)
     *  3.7 swap、find和clear
     *  3.8 流插入和流提取运算符的重载
     *  整体源码

--------------------

## 1. STL的介绍 ##

> `STL`**(standard template libaray-标准模板库)：** 是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。

### 1.1 STL的六大组件 ###

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

--------------------

### 1.2 STL的版本 ###

>  *  **原始版本**  
>     Alexander Stepanov、Meng Lee 在惠普实验室完成的原始版本，本着开源精神，他们声明允许任何人任意运用、拷贝、修改、传播、商业使用这些代码，无需付费。唯一的条件就是也需要向原始版本一样做开源使用。 HP 版本–所有STL实现版本的始祖。
>  *  **P. J. 版本**  
>     由P. J. Plauger开发，继承自HP版本，被Windows Visual C++采用，不能公开或修改，缺陷：可读性比较低，符号命名比较怪异。
>  *  **RW版本**  
>     由Rouge Wage公司开发，继承自HP版本，被C+ + Builder 采用，不能公开或修改，可读性一般。
>  *  **SGI版本**  
>     由Silicon Graphics Computer Systems，Inc公司开发，继承自HP版 本。被GCC(Linux)采用，可移植性好，可公开、修改甚至贩卖，从命名风格和编程 风格上看，阅读性非常高。我们后面学习STL要阅读部分源代码，主要参考的就是这个版本。

--------------------

### 1.3 STL的缺陷 ###

> 1.  STL库的更新太慢了。这个得严重吐槽，上一版靠谱是C++98，中间的C++03基本一些修订。C++11出来已经相隔了13年，STL才进一步更新。
> 2.  STL现在都没有支持线程安全。并发环境下需要我们自己加锁。且锁的粒度是比较大的。
> 3.  STL极度的追求效率，导致内部比较复杂。比如类型萃取，迭代器萃取。
> 4.  STL的使用会有代码膨胀的问题，比如使用vector/vector/vector这样会生成多份代码，当然这是模板语法本身导致的。

--------------------

## 2. string的使用 ##

### 2.1 为什么要学习string类？ ###

C语言中，字符串是以’\\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

**string类的注意事项：**

> 1.  string是表示字符串的字符串类
> 2.  该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
> 3.  string在底层实际是：basic\_string模板类的别名，typedef basic\_string<char, char\_traits, allocator>string;
> 4.  不能操作多字节或者变长字符的序列。

--------------------

### 2.2 常见构造 ###

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

int main()
    {
        
    	string s1;
    	string s2("hello world");
    	string s3 = "hello world";
    	string s4(s3, 6, 3);
    	cout << s4 << endl;
    	string s5(s3, 6, 13);
    	cout << s5 << endl;
    	string s6(s3, 6);
    	cout << s6 << endl;
    	string s7("hello world", 5);
    	cout << s7 << endl;
    	string s8(10, '*');
    	cout << s8 << endl;
    	//对于string的访问我们可以直接使用[],因为重载了[],
    	//所以string类可以像数组一样访问，当然也可以用范围for循环
    	for (size_t i = 0; i < s2.size(); ++i)
    	{
        
    		s2[i]++;
    	}
    	cout << s2 << endl;
    	for (auto e : s2)
    	{
        
    		cout << e << " ";
    	}
    	cout << endl;
    	return 0;
    }

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

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

这个构造函数的意思是从str中的第pos个位置开始，取len个字符来初始化目标对象，但我们可以看到这里的第三个参数用到了缺省参数npos，如果第三个参数的大小超过了str的长度，会直接取到str的末尾，下面我们来看一下这里的npos指的是多少？

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

这里的npos指的是无符号的-1，表示的是4294967295，因为我们的字符串最大的长度是不可能超过这么长的，所以当我们第三个参数默认不给的时候，他会从pos位置一直取到字符串的结尾。

--------------------

### 2.3 Iterator迭代器 ###

> 迭代器和指针非常类似，它可以是需要的任意类型，通过迭代器可以指向容器中的某个元素，如果需要，还可以对该元素进行读/写操作。虽然迭代器像指针，但它不一定是指针，而所有的容器都可以使用迭代器来进行遍历和修改。

? **正向迭代器**

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

int main()
    {
        
    	string s1("hello world");
    	string::iterator it = s1.begin();
    	while (it != s1.end())
    	{
        
    		cout << *it << " ";
    		++it;
    	}
    	cout << endl;
    	//用迭代器修改容器中的内容
    	it = s1.begin();
    	while (it != s1.end())
    	{
        
    		*it += 1;
    		cout << *it << " ";
    		++it;
    	}
    	return 0;
    }

![在这里插入图片描述][1a965f41cf244b0a954c7bc4517abe78.png]  
![在这里插入图片描述][f050427d0b0344b585d7015f745e146d.png]

这里我们还需要注意的是迭代器的区间是左闭右开的，这里的`begin()`指向的是字符串中的第一个字符，而`end()`指向的是最后一个字符后面的’\\0’。

? **反向迭代器**

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

int main()
    {
        
    	string s1("hello world");
    	string::reverse_iterator it = s1.rbegin();
    	while (it != s1.rend())
    	{
        
    		cout << *it << " ";
    		++it;
    	}
    	return 0;
    }

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

? **const迭代器**

当我们创建一个const修饰的对象时，就必须要用到const迭代器了，const迭代器是只读的，不能够修改容器中的内容。当然，const迭代器既有正向迭代器，又有反向迭代器。

int main()
    {
        
    	const string s1("hello world");
    	string::const_iterator it1 = s1.begin();
    	while (it1 != s1.end())
    	{
        
    		cout << *it1 << " ";
    		++it1;
    	}
    	cout << endl;
    	string::const_reverse_iterator it2 = s1.rbegin();
    	while (it2!= s1.rend())
    	{
        
    		cout << *it2 << " ";
    		++it2;
    	}
    	cout << endl;
    	return 0;
    }

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

这里还有一点我们需要注意的是：所有的迭代器都可以使用auto去自动识别，因为auto是可以根据后面对象的类型自动去识别迭代器类型的。但是这样写的话可读性也会变的很差。

int main()
    {
        
    	const string s1("hello world");
    	auto it1 = s1.begin();
    	while (it1 != s1.end())
    	{
        
    		cout << *it1 << " ";
    		++it1;
    	}
    	cout << endl;
    	auto it2 = s1.rbegin();
    	while (it2 != s1.rend())
    	{
        
    		cout << *it2 << " ";
    		++it2;
    	}
    	cout << endl;
    	return 0;
    }

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

--------------------

### 2.4 Capacity ###

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

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

这里我们可以先写一个简单的程序来观察一下string是怎么扩容的：

在vs下的扩容情况：

int main()
    {
        
    	string s;
    	size_t sz = s.capacity();
    	cout << "making s grow:\n";
    	cout << "capacity changed: " << sz << '\n';
    	for (int i = 0; i < 100; ++i)
    	{
        
    		s.push_back('c');
    		if (sz != s.capacity())
    		{
        
    			sz = s.capacity();
    			cout << "capacity changed: " << sz << '\n';
    		}
    	}
    	return 0;
    }

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

在g++下的扩容情况：

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

这里我们可以看到，在不同的编译器下，string的扩容效果是不同的。下面我们来看一下reserve和resize的区别：

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

int main()
    {
        
    	// 扩容
    	string s1("hello world");
    	s1.reserve(100);
    	cout << s1.size() << endl;
    	cout << s1.capacity() << endl;
    
    	// 扩容+初始化
    	string s2("hello world");
    	s2.resize(100, 'x');
    	cout << s2.size() << endl;
    	cout << s2.capacity() << endl;
    
    	// 比size小，删除数据，保留前5个
    	s2.resize(5);
    	cout << s2.size() << endl;
    	cout << s2.capacity() << endl;
    	return 0;
    }

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

这里的`reserve`主要是为字符串预留空间，只会影响`capacity`的大小。而resize则是将字符串的个数改为n个，多出的空间使用字符c来填充。它会影响size和capacity的大小。一般情况下我们可以提前使用reserve开空间，避免频繁的扩容。

--------------------

### 2.5 Modifiers ###

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

? **insert和erase**

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

对于`insert/erase`我们不推荐经常使用，能少用就少用，因为他们可能都存在要挪动数据，效率低下。下面我们举几个例子来看一下他们的用法：

int main()
    {
        
    	string s1("world");
    	s1.insert(0, "hello");
    	cout << s1 << endl;
    	cout << "--------------------" << endl;
    	//s1.insert(5, 1, ' ');
    	//s1.insert(5, " ");
    	s1.insert(s1.begin()+5, ' ');
    	cout << s1 << endl;
    	cout << "--------------------" << endl;
    	string s2("hello world");
    	//s2.erase(5, 1);
    	s2.erase(s2.begin() + 5);
    	cout << s2 << endl;
    	cout << "--------------------" << endl;
    	//s2.erase(5, 30);
    	s2.erase(5);
    	cout << s2 << endl;
    	return 0;
    }

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

? **replace和swap**

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

int main()
    {
        
    	string s1("hello world");
    	s1.replace(5, 1, "%%d");
    	cout << s1 << endl;
    
    	string s2("I love you!");
    	string s3("Wake up bro!");
    	cout << "s2:" << s2 << endl;
    	cout << "s3:" << s3 << endl;
    	cout << "-------------------" << endl;
    	s2.swap(s3);
    	cout << "s2:" << s2 << endl;
    	cout << "s3:" << s3 << endl;
    	return 0;
    }

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

--------------------

### 2.6 String operations ###

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

? **c\_str**

在某些场景中只支持对C形式的字符串，即字符数组进行操作，比如网络传输、fopen，而不支持对C++中的 string 对象进行操作，所以 string 提供了c\_str，用于返回C形式的字符串。

![在这里插入图片描述][1596c78d3705461a80e4f34e4a3a2edf.png]  
![在这里插入图片描述][e8b09275e05748fa8570a0835c2ddcb1.png]

? **find和rfind**

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

find函数用于返回字符在string中首次出现的位置（从前往后找），rfind函数用于返回字符在string中首次出现的位置（从后往前找）。

![在这里插入图片描述][0988ad0617c040dd83c1660d3b748196.png]  
![在这里插入图片描述][3ef1da3ebf554f71b694f3acd1c9ff28.png]

? **find\_first\_of**

![在这里插入图片描述][228a590a202641b0a50ba23d3fe72568.png]  
first\_first\_of函数用于返回在string中寻找与字符/字符数组/string中任意一个字符匹配的元素的位置。

int main()
    {
        
    	std::string str("Please, replace the vowels in this sentence by asterisks.");
    	//把str中包含"abcdv"中任何一个的字符替换成'*'
    	std::size_t found = str.find_first_of("abcdv");
    	while (found != std::string::npos)
    	{
        
    		str[found] = '*';
    		found = str.find_first_of("abcdv", found + 1);
    	}
    	std::cout << str << '\n';
    	return 0;
    }

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

? **substr**

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

将string中第pos个位置开始往后的n个字符构造成一个新的string对象并返回。

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

--------------------

## 3. string的模拟实现 ##

### 3.1 构造函数 ###

我们在写构造函数的时候，一般会有有参构造和无参构造两种构造函数。

//无参构造和有参构造的错误写法
    string()
    	:_str(nullptr)
    	,_size(0)
    	,_capacity(0)
    {
        }
    string(const char* str)
    	:_str(str)
    	,_size(strlen(str))
    	,_capacity(strlen(str))
    {
        }

我们可以将构造寒素写成有参和无参两种形式，但是因为`char *str`被const修饰了，所以传参的时候会导致权限的放大所以会报错，因此我们只能将私有成员变量\_str用const修饰，但是这势必会导致无法修改\_str指向的内容。而且当我们使用无参构造去创建一个对象的时候，由于\_str指向的是一个空指针，如果这个对象后续没有开空间，调用析构函数所以delete的时候必定会导致问题的出现。

基于上面的种种原因，我们可以在初始化的时候直接使用缺省参数构造一个空字符串（注意不能是nullptr，因为使用strlen的时候会出问题），如果没有传参就使用缺省值，当然如果传入的是空字符串。我们需要将空间开大一些，因为后期使用`push_back`需要第一次就扩容的时候，使用二倍扩容会出问题。

//构造函数
    string(const char *s = "")
    	:_size(strlen(s))
    {
        
    	_capacity = _size == 0 ? 3 : _size;
    	_str = new char[_capacity + 1];
    	strcpy(_str, s);
    }

--------------------

### 3.2 拷贝构造函数 ###

string(const string& s)
    	:_size(s._size)
    	, _capacity(s._capacity)
    {
        
    	_str = new char[_capacity + 1];
    	strcpy(_str, s._str);
    }
    //拷贝构造现代写法s2(s1)
    string(const string& s)
    	:_str(nullptr)
    	,_size(0)
    	,_capacity(0)
    {
        
    	string tmp(s._str);
    	swap(tmp);
    }

对于拷贝构造函数，如果我们不写，编译器会自动默认生成，对于内置类型，编译器的默认拷贝构造函数能够很好的处理，但是如果内置的成员变量具有资源的申请，就会导致浅拷贝问题的出现。所以我们只能重写深拷贝构造函数。

当我们使用拷贝构造的现代写法时，一定要走初始化列表，如果不走初始化列表，s2的数据将会是随机值，随机指向一块空间，将tmp和s2的数据交换后，tmp指向的空间将会被销毁，那么随即指向的空间将会被delete掉，程序奔溃。

--------------------

### 3.3 赋值运算符重载和析构函数 ###

//赋值运算符重载(传统写法)
    string& operator=(const string& s)
    {
        
    	if (this == &s)
    		return *this;
    	char* tmp = new char[strlen(s._str) + 1];
    	strcpy(tmp, s._str);
    	delete[] _str;//这里一定要记住先释放原来的空间，避免造成内存泄露
    
    	_str = tmp;
    	_size = s._size;
    	_capacity = s._capacity;
    	return *this;
    }
    //赋值运算符重载（现代写法1）
    string& operator=(const string& s)
    {
        
    	if (this != &s)
    	{
        
    		string tmp(s);
    		swap(tmp);
    	}
    	return *this;
    }
    //赋值运算符重载（现代写法2）
    string& operator=(string s)
    {
        
    	swap(s);
    	return *this;
    }
    ~string()
    {
        
    	delete[] _str;
    	_str = nullptr;
    	_capacity = _size = 0;
    }

赋值运算符重载也属于类的六大默认成员函数之一，如果我们不写，编译器也会自动默认生成。但是它和编译器自动生成的默认拷贝构造函数一样都是按字节拷贝，同样会导致浅拷贝问题的出现。

为了解决这个问题，我们只能重新写赋值运算符重载函数，如果是对象自己赋值自己的话，直接返回对象本身就可以了。这里我们先开一块临时的内存空间将要拷贝的数据放进去，这里我们一定要注意：先释放原来对象所指向的空间，避免造成内存泄漏。

赋值运算符重载的现代写法有两种，第一种写法是先拷贝构造一个临时对象，然后在调用swap对象将本对象的数据与其做交换。第二种写法是直接利用形参所拷贝构造的对象进行进行交换。

--------------------

### 3.4 常用接口(c\_str、\[ \]、迭代器、size和capacity) ###

? **c\_str的模拟实现**

//模拟实现c_str()
    const char* c_str()
    {
        
    	return _str;
    }

? **重载\[ \]**

//重载[]
    char& operator[](int pos)
    {
        
    	return _str[pos];
    }
    const char& operator[](int pos)const
    {
        
    	return _str[pos];
    }

因为普通对象是可读可写的但是const对象是只可读不可写的，所以我们需要对\[ \]的重载一份针对于const版本的。

? **size和capacity**

//获取size()
    int size()const
    {
        
    	return _size;
    }
    //获取capacity
    int capacity()
    {
        
    	return _capacity;
    }

--------------------

### 3.5 关系运算符的重载 ###

//比较两个对象关系的运算符重载
    bool operator>(const string& s)const//重载>
    {
        
    	return strcmp(_str, s._str) > 0;
    }
    
    bool operator==(const string& s)const//重载==
    {
        
    	return strcmp(_str, s._str) == 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);
    }

--------------------

### 3.6 插入、删除和容量操作(reserve和resize) ###

? **reserve的实现**

//reserve的实现(扩容)
    void reserve(size_t n)
    {
        
    	if (n > _capacity)
    	{
        
    		char* tmp = new char[n + 1];
    		strcpy(tmp, _str);
    
    		delete[] _str;
    		_str = tmp;
    		_capacity = n;
    	}
    }

因为reserve是只能扩容的，所以我们需要先判断一下需要扩的容量是否大于原来的容量。

? **resize的实现**

//resize的实现
    void resize(size_t n, char ch)
    {
        
    	if (n <= _size)
    	{
        
    		_size = n;
    		_str[n] = '\0';
    	}
    	else
    	{
        
    		if (n > _capacity)
    		{
        
    			reserve(n);
    		}
    		int i = _size;
    		while (i < n)
    		{
        
    			_str[i] = ch;
    			i++;
    		}
    		_size = n;
    		_str[_size] = '\0';
    	}
    }

? **push\_back的实现**

//push_back的实现
    void push_back(char ch)
    {
        
    	if (_size + 1 > _capacity)
    	{
        
    		reserve(_capacity * 2);
    	}
    	_str[_size++] = ch;
    	_str[_size] = '\0';
    }

? **append的实现**

//append的实现
    void append(const char* s)
    {
        
    	size_t len = strlen(s);
    	if (_size +len > _capacity)
    	{
        
    		reserve(_capacity + len);
    	}
    	strcpy(_str + _size, s);
    	_size += len;
    }

? **重载+=**

//重载+=
    string& operator+=(char ch)
    {
        
    	push_back(ch);
    	return *this;
    }
    string& operator+=(const char* s)
    {
        
    	append(s);
    	return *this;
    }

? **insert的实现**

//insert的实现
    string& insert(size_t pos, char ch)
    {
        
    	assert(pos <= _size);
    	if (_size + 1 > _capacity)
    	{
        
    		reserve(_size * 2);
    	}
    	size_t end = _size + 1;
    	while (end > pos)
    	{
        
    		_str[end] = _str[end - 1];
    		end--;
    	}
    	_str[pos] = ch;
    	_size++;
    	return *this;
    }
    string& insert(size_t pos, const char* str)
    {
        
    	assert(pos <= _size);
    	size_t len = strlen(str);
    	if (_size + len > _capacity)
    	{
        
    		reserve(_size + len);
    	}
    	size_t end = _size + len;
    	while (end > pos + len - 1)
    	{
        
    		_str[end] = _str[end - len];
    		end--;
    	}
    	/*size_t end = _size;
    	for (size_t i = 0; i < _size - pos + 1; ++i)
    	{
    		_str[end + len] = _str[end];
    		--end;
    	}*/
    	strncpy(_str + pos, str, len);
    	_size += len;
    
    	return *this;
    }

? **erase的实现**

//erase的实现
    string& erase(size_t pos = 0, size_t len = npos)
    {
        
    	assert(pos <= _size);
    	if (len == npos || len + pos >= _size)
    	{
        
    		_str[pos] = '\0';
    		_size = pos;
    	}
    	else
    	{
        
    		strcpy(_str + pos, _str + pos + len);
    		_size -= len;
    	}
    	return *this;
    }

--------------------

### 3.7 swap、find和clear ###

? **swap的实现**

//swap的实现
    void swap(string& str)
    {
        
    	std::swap(_str, str._str);
    	std::swap(_size, str._size);
    	std::swap(_capacity, str._capacity);
    }

? **find的实现**

//find的实现
    size_t find(const char* str, size_t pos = 0)
    {
        
    	assert(pos < _size);
    	char* tmp = strstr(_str + pos, str);
    	if (tmp == nullptr )
    	{
        
    		return npos;
    	}
    	return tmp - _str;
    }
    
    size_t find(char ch, size_t pos = 0)
    {
        
    	assert(pos < _size);
    	for (size_t i = pos; i < _size; i++)
    	{
        
    		if (ch == _str[i])
    		{
        
    			return i;
    		}
    	}
    	return npos;
    }

? **clear的实现**

void clear()
    {
        
    	_str[0] = '\0';
    	_size = 0;
    }

### 3.8 流插入和流提取运算符的重载 ###

//重载<<运算符
    ostream& operator<<(ostream& out,const string& str)
    {
        
    	for (auto e : str)
    	{
        
    		out << e;
    	}
    	return out;
    }
    
    //重载>>运算符
    istream& operator >> (istream& in, string& str)
    {
        
    	str.clear();
    	size_t i = 0;
    	char tmp[128];
    	char ch = in.get();
    	while (ch != ' ' && ch != '\n')
    	{
        
    		tmp[i++] = ch;
    		if (i == 127)
    		{
        
    			tmp[i] = '\0';
    			str += tmp;
    			i = 0;
    		}
    		ch = in.get();
    	}
    	if (i != 0)
    	{
        
    		tmp[i] = '\0';
    		str += tmp;
    	}
    	return in;
    }

流插入和流提取运算符，因为他们需要和流对象和对象抢占左操作数，所以我们需要将他们重载成全局函数，但是如果我们的重载函数不需要访问私有成员，那么我们就不需要将他们声明为类的友元函数。

> cin和scanf一样，只要遇到`空格`或者`'\n'`就会被忽略掉，所以我们需要用`get`函数一个字符一个字符的获取，当然了如果原来的对象中有有内容的话，我们需要先将原来对象中的内容清空，然后再重新输入新的内容。所以，这里我们在每一次调用流提取重载函数时，先将原来对象中的内容使用`clear`函数清除所有的数据。流插入运算符的重载因为这里比较简单则不再叙述。

--------------------

### 整体源码 ###

#include<cassert>
    #include<cstring>
    #include<iostream>
    using namespace std;
    
    namespace cjl
    {
        
    	class string
    	{
        
    	public:
    		//迭代器的模拟实现
    		typedef char* iterator;//普通迭代器
    		typedef const char* const_iterator;//const迭代器
    		iterator begin()
    		{
        
    			return _str;
    		}
    		iterator end()
    		{
        
    			return _str + _size;
    		}
    
    		const_iterator begin()const
    		{
        
    			return _str;
    		}
    		const_iterator end()const
    		{
        
    			return _str + _size;
    		}
    		//构造函数
    		string(const char *s = "")
    			:_size(strlen(s))
    		{
        
    			_capacity = _size == 0 ? 3 : _size;
    			_str = new char[_capacity + 1];
    			strcpy(_str, s);
    		}
    
    		//拷贝构造
    		string(const string& s)
    			:_size(s._size)
    			, _capacity(s._capacity)
    		{
        
    			_str = new char[_capacity + 1];
    			strcpy(_str, s._str);
    		}
    
    		//拷贝构造现代写法
    		/*string(const string& s)
    			:_str(nullptr)
    			,_size(0)
    			,_capacity(0)
    		{
    			string tmp(s._str);
    			swap(tmp);
    		}*/
    
    		//赋值运算符重载
    		string& operator=(const string& s)
    		{
        
    			if (this == &s)
    				return *this;
    			char* tmp = new char[strlen(s._str) + 1];
    			strcpy(tmp, s._str);
    			delete[] _str;//这里一定要记住先释放原来的空间，避免造成内存泄露
    
    			_str = tmp;
    			_size = s._size;
    			_capacity = s._capacity;
    			return *this;
    		}
    
    		//赋值运算符重载（现代写法1）
    		/*string& operator=(const string& s)
    		{
    			if (this != &s)
    			{
    				string tmp(s);
    				swap(tmp);
    			}
    			return *this;
    		}*/
    		//赋值运算符重载（现代写法2）
    		/*string& operator=(string s)
    		{
    			swap(s);
    			return *this;
    		}*/
    		//析构函数
    		~string()
    		{
        
    			delete[] _str;
    			_str = nullptr;
    			_capacity = _size = 0;
    		}
    
    		//模拟实现c_str()
    		const char* c_str()
    		{
        
    			return _str;
    		}
    
    		//重载[]
    		char& operator[](int pos)
    		{
        
    			return _str[pos];
    		}
    		const char& operator[](int pos)const
    		{
        
    			return _str[pos];
    		}
    
    		//获取size()
    		int size()const
    		{
        
    			return _size;
    		}
    
    		//获取capacity
    		int capacity()
    		{
        
    			return _capacity;
    		}
    
    		//比较两个对象关系的运算符重载
    		bool operator>(const string& s)const//重载>
    		{
        
    			return strcmp(_str, s._str) > 0;
    		}
    		
    		bool operator==(const string& s)const//重载==
    		{
        
    			return strcmp(_str, s._str) == 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);
    		}
    
    		//reserve的实现(扩容)
    		void reserve(size_t n)
    		{
        
    			if (n > _capacity)
    			{
        
    				char* tmp = new char[n + 1];
    				strcpy(tmp, _str);
    
    				delete[] _str;
    				_str = tmp;
    				_capacity = n;
    			}
    		}
    		
    		//resize的实现
    		void resize(size_t n, char ch)
    		{
        
    			if (n <= _size)
    			{
        
    				_size = n;
    				_str[n] = '\0';
    			}
    			else
    			{
        
    				if (n > _capacity)
    				{
        
    					reserve(n);
    				}
    				int i = _size;
    				while (i < n)
    				{
        
    					_str[i] = ch;
    					i++;
    				}
    				_size = n;
    				_str[_size] = '\0';
    			}
    		}
    		
    		//push_back的实现
    		void push_back(char ch)
    		{
        
    			if (_size + 1 > _capacity)
    			{
        
    				reserve(_capacity * 2);
    			}
    			_str[_size++] = ch;
    			_str[_size] = '\0';
    		}
    
    		//append的实现
    		void append(const char* s)
    		{
        
    			size_t len = strlen(s);
    			if (_size +len > _capacity)
    			{
        
    				reserve(_capacity + len);
    			}
    			strcpy(_str + _size, s);
    			_size += len;
    		}
    
    		//重载+=
    		string& operator+=(char ch)
    		{
        
    			push_back(ch);
    			return *this;
    		}
    		string& operator+=(const char* s)
    		{
        
    			append(s);
    			return *this;
    		}
    
    		//insert的实现
    		string& insert(size_t pos, char ch)
    		{
        
    			assert(pos <= _size);
    			if (_size + 1 > _capacity)
    			{
        
    				reserve(_size * 2);
    			}
    			size_t end = _size + 1;
    			while (end > pos)
    			{
        
    				_str[end] = _str[end - 1];
    				end--;
    			}
    			_str[pos] = ch;
    			_size++;
    			return *this;
    		}
    		string& insert(size_t pos, const char* str)
    		{
        
    			assert(pos <= _size);
    			size_t len = strlen(str);
    			if (_size + len > _capacity)
    			{
        
    				reserve(_size + len);
    			}
    			size_t end = _size + len;
    			while (end > pos + len - 1)
    			{
        
    				_str[end] = _str[end - len];
    				end--;
    			}
    			/*size_t end = _size;
    			for (size_t i = 0; i < _size - pos + 1; ++i)
    			{
    				_str[end + len] = _str[end];
    				--end;
    			}*/
    			strncpy(_str + pos, str, len);
    			_size += len;
    
    			return *this;
    		}
    
    		//erase的实现
    		string& erase(size_t pos = 0, size_t len = npos)
    		{
        
    			assert(pos <= _size);
    			if (len == npos || len + pos >= _size)
    			{
        
    				_str[pos] = '\0';
    				_size = pos;
    			}
    			else
    			{
        
    				strcpy(_str + pos, _str + pos + len);
    				_size -= len;
    			}
    			return *this;
    		}
    
    		//swap的实现
    		void swap(string& str)
    		{
        
    			std::swap(_str, str._str);
    			std::swap(_size, str._size);
    			std::swap(_capacity, str._capacity);
    		}
    
    		//find的实现
    		size_t find(const char* str, size_t pos = 0)
    		{
        
    			assert(pos < _size);
    			char* tmp = strstr(_str + pos, str);
    			if (tmp == nullptr )
    			{
        
    				return npos;
    			}
    			return tmp - _str;
    		}
    
    		size_t find(char ch, size_t pos = 0)
    		{
        
    			assert(pos < _size);
    			for (size_t i = pos; i < _size; i++)
    			{
        
    				if (ch == _str[i])
    				{
        
    					return i;
    				}
    			}
    			return npos;
    		}
    
    		void clear()
    		{
        
    			_str[0] = '\0';
    			_size = 0;
    		}
    	private:
    		char* _str;
    		int _size;
    		int _capacity;
    		//static const size_t npos = -1;
    		//只有const静态整形变量才能够在类内提供初始值，
    		//如果是static const double/float则不可以在类内提供初始值。static const int/short可以在类内提供初始值。
    		//static const size_t npos;
    		static size_t npos;
    	};
    
    	//const size_t string::npos = -1;
    	size_t string::npos = -1;
    
    
    	//重载<<运算符
    	ostream& operator<<(ostream& out,const string& str)
    	{
        
    		for (auto e : str)
    		{
        
    			out << e;
    		}
    		return out;
    	}
    
    	//重载>>运算符
    	istream& operator >> (istream& in, string& str)
    	{
        
    		str.clear();
    		size_t i = 0;
    		char tmp[128];
    		char ch = in.get();
    		while (ch != ' ' && ch != '\n')
    		{
        
    			tmp[i++] = ch;
    			if (i == 127)
    			{
        
    				tmp[i] = '\0';
    				str += tmp;
    				i = 0;
    			}
    			ch = in.get();
    		}
    		if (i != 0)
    		{
        
    			tmp[i] = '\0';
    			str += tmp;
    		}
    		return in;
    	}
    }

[2fc547a122c244e5aadfabb2e199970d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/eadfce11370f43adb07578f35e6c6609.png
[6fd892945e244780b62b3a6002601259.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/d1547345e4bc43b5860a30048ef32fdc.png
[3e1b7559446947099c75f93ca117a2b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/13886896d4444118a6233f2d280a6f7d.png
[f7984dbafd6345c0b12f86eb39e31966.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/616b058fe5ec4416a2d1f3871f485216.png
[70a4cbf051b2446ba98c992acec7b76a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/c3c7cb797dcf44bb80447c224b7511e5.png
[af105c8084884442852adb3bbc090a34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/cea4f1e5779e42ad97238f96271560e3.png
[1a965f41cf244b0a954c7bc4517abe78.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/2f07cd39887541028e10eb3800dd4b18.png
[f050427d0b0344b585d7015f745e146d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/27b979a1dd6248b797d22e31e7fd2d5a.png
[c7de00c3c3b844e4a705ed10da0d1f63.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/fcce741dda9e479e9eb8d47af697649d.png
[fb8512a2dd0f45f3b8a07dc76d3266ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/59e3f4462f974c13a2a69317c5cecb39.png
[ece20653a1724e0590d19a4aaedb859f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/a52759dc7bbe46e79f204298f269945f.png
[41d6c29dfc814cba9fb22f17664e53ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/a8eceb20f12e4334a76fda57866891b6.png
[6d37d8f3fad541ebaf459bf535acded8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/a4e7334a61554fc0852d321df089b457.png
[e6d1120a729a4c819dc0fd9288a9be8f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/d592e00f5ca44f379db93d11cebf47b6.png
[eae5efa095e142e4a12d8b797ae324db.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/9034d2e6fa714e06bcb810bf6699fe89.png
[d6eb1b882cf443c9bb77d4aa655b398b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/bc975577a00a4612bb2ea38cda181151.png
[199786bdb6514c368175087bf6ce2ebd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/9c2aad55e4ab4bc380d5b7d97f55b5d1.png
[3ba95baf9e814a5abddb55fa5e39e17e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/0828abf759954ff8ae0f354328b04880.png
[4e22bf28b95448e1a5f5f3886e3314a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/2a5405048e2b42cf95a933a751eb89e7.png
[7edcd1e7dd814c8da04ecdbc24a9e60c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/c13d88c8ec1447b5a8f6e403a6e7a2be.png
[ddc21bacdb03497dae5c8c5e8d67f981.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/5220931ddae249e5827eae120289ba0c.png
[8513370f61d443669481c689b9141bde.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/7c3aeed58951448f9236e7dd03d735bf.png
[30b81a0900334ad6a27509eeffe5c59f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/f0b34d997453496b8a34e9ffaf207920.png
[b61551aae9a04aafb5932fdfb2bb7716.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/4cd53f8c8dfa4edf9d42bd8be1be0a78.png
[7754945ac28b4bbe8b90eec43546b58e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/17971bf7538a4b70bb80b3bda2a92235.png
[1596c78d3705461a80e4f34e4a3a2edf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/deef656325d048559e1f736f85ecf2b2.png
[e8b09275e05748fa8570a0835c2ddcb1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/e4856fd9277a47faa6fda8f1f27e3de6.png
[8393446c09b34af28cae670881601fca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/0d6fbcec9d6f4cecbb516a47586a37fe.png
[0988ad0617c040dd83c1660d3b748196.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/2f542fe3f7fb438f845dc4dfe55c5272.png
[3ef1da3ebf554f71b694f3acd1c9ff28.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/24aa014d079147718d9535d39eeef178.png
[228a590a202641b0a50ba23d3fe72568.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/d7ab992e613646afa916c2ac61c49cab.png
[e93d5129467848b08c2af65566c3f1d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/82fc72da18134cf28c0c31543a7821e4.png
[6b8602f3a88d4308bd5c9d5a7e525d20.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/703101fdcc734bd8b347d6ec13e9bc53.png
[bdc02b89af5948649072d36addcb13ee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/3a808defddcb4fdfb4de2641418519fa.png