[C++] string类的介绍与构造的模拟实现，进来看吧，里面有空调

女爷i 2023-10-14 21:49 5阅读 0赞

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

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

*  1、string类的出现
 *   *  1.1 C语言中的字符串
 *  2、标准库中的string类
 *   *  2.1 string类
 *  3、string类的常见接口说明及模拟实现
 *   *  3.1 string的常见构造
     *  3.2 string的构造函数
     *  3.3 string的拷贝构造
     *  3.4 string的赋值构造
 *  4、完整代码

## 1、string类的出现 ##

### 1.1 C语言中的字符串 ###

C语言中，字符串是以’\\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合面向对象的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。  
因此C++中，为了让我们更简单、方便、快捷的使用字符串类型，C++提供了string类。

## 2、标准库中的string类 ##

### 2.1 string类 ###

[string类文档介绍][string]  
**string类在使用的时候我们需要包含头文件 \#include ，以及using namespace std;**

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. 不能操作多字节或者变长字符的序列。**

## 3、string类的常见接口说明及模拟实现 ##

### 3.1 string的常见构造 ###

<table> 
 <thead> 
  <tr> 
   <th>(<a href="https://cplusplus.com/reference/string/string/string/" rel="nofollow">constructor</a>)函数名称</th> 
   <th>功能说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>string()</td> 
   <td>构造空的string类对象，即空字符串</td> 
  </tr> 
  <tr> 
   <td>string(const char* s)</td> 
   <td>用C-string来构造string类对象</td> 
  </tr> 
  <tr> 
   <td>string(size_t n, char c)</td> 
   <td>string类对象中包含n个字符c</td> 
  </tr> 
  <tr> 
   <td>string(const string&amp;s)</td> 
   <td>拷贝构造函数</td> 
  </tr> 
 </tbody> 
</table>

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

### 3.2 string的构造函数 ###

namespace s
    {
        
    	class string
    	{
        
    	public:
        	//string()
    		//	:_str(new char[1]{ '\0' })//这里开一个空间，并赋值为\0，如果直接赋值为nullptr的话
    		//	,_size(0)				  //在实例化一个无参对象后，对对象进行操作的时候会引发空指针异常
    		//	,_capacity(0)
    		//{}
        
    		//全缺省构造函数
    		string(const char* str = "")//常量字符串默认以\0结尾，因此不需要给
    			: _size(strlen(str))
    			, _capacity(_size)
    		{
        
    			_str = new char[_capacity + 1];//多开一个空间，需要存放\0
    			strcpy(_str, str);//将字符串拷贝到_str
    		}
    
    	private:
    		char* _str;
    		size_t _size;//有效存储字符个数
    		size_t _capacity;//实际空间
    	};
    }

**这里我们用一个全缺省将无参构造与构造都包括了。**  
这个构造函数很简单，这里就不多讲了，大家应该可以看懂。

### 3.3 string的拷贝构造 ###

传统写法：

//拷贝构造
    string(const string& s)
        : _size(strlen(s._str))
        , _capacity(_size)
    {
        
        _str = new char[_capacity + 1];
        strcpy(_str, s._str);
    }

现代写法：

void swap(string& s)
    {
        
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }
    //现代写法 s1(s2)
    string(const string& s)
        :_str(nullptr)
        ,_size(0)
        ,_capacity(0)
    {
        
        string tmp(s._str);//构造
        swap(tmp);//this->swap(s);
    }

**库里提供了交换函数，我们封装一个交换函数，内部的实现就使用库里面的swap，我们拷贝构造函数里面先调用构造函数，实例化一个tmp，再将tmp与this交换。**

### 3.4 string的赋值构造 ###

传统写法：

string& operator=(const string& s)
    {
        
    	if (this != &s)
    	{
        
    		string tmp(s);//拷贝构造
    		swap(tmp);
    	}
    	return *this;
    }

现代写法：这里与拷贝构造的现代写法是类似的，不再多说。

void swap(string& s)
    {
        
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }
    string& operator=(const string& s)
    {
        
        if (this != &s)
        {
        
            string tmp(s);//拷贝构造
            swap(tmp);
        }
        return *this;
    }

**我们其实可以对现代写法继续精简一下，我们这里参数是引用传参，我们不用引用就会产生一次拷贝，对拷贝的形参直接进行交换，这样就可以简化写法，但是这里的效率其实是一样的，都是一次拷贝构造 + 一次交换。**

// 极致写法，效率与上面一样
    string& operator=(string tmp)//参数直接调用拷贝构造
    {
        
        swap(tmp);
    
        return *this;
    }

## 4、完整代码 ##

#include <string.h>
    #include <algorithm>
    using namespace std;
    
    namespace s
    {
        
    	class string
    	{
        
    	public:
    		//string()
    		//	:_str(new char[1]{ '\0' })//这里开一个空间，并赋值为\0，如果直接赋值为nullptr的话
    		//	,_size(0)				  //在实例化一个无参对象后，对对象进行操作的时候会引发空指针异常
    		//	,_capacity(0)
    		//{}
    
    		//全缺省构造函数
    		string(const char* str = "")//常量字符串默认以\0结尾，因此不需要给
    			:_size(strlen(str))
    			,_capacity(_size)
    		{
        
    			_str = new char[_capacity + 1];//多开一个空间，需要存放\0
    			strcpy(_str, str);//将字符串拷贝到_str
    		}
    
    		//拷贝构造
    		// 传统写法
    		//string(const string& s)
    		//	:_size(s._size)
    		//	,_capacity(s._capacity)
    		//{
        
    		//	_str = new char[s._capacity + 1];
    		//	strcpy(_str, s._str);
    		//}
    
    		void swap(string& s)
    		{
        
    			std::swap(_str, s._str);
    			std::swap(_size, s._size);
    			std::swap(_capacity, s._capacity);
    		}
    		//现代写法 s1(s2)
    		string(const string& s)
    			:_str(nullptr)
    			,_size(0)
    			,_capacity(0)
    		{
        
    			string tmp(s._str);//构造
    			swap(tmp);//this->swap(s);
    		}
    
    		//赋值
    		// 传统写法
    		//string& operator=(const string& s)
    		//{
        
    		//	if (this != &s)
    		//	{
        
    		//		char* tmp = new char[s._capacity];
    		//		strcpy(tmp, s._str);
    
    		//		delete[] _str;
    		//		_str = tmp;//将tmp字符串直接给_str，类似浅拷贝
    		//		_size = s._size;
    		//		_capacity = s._capacity;
    		//	}
    
    		//	return *this;
    		//}
    
    		//现代写法
    		//string& operator=(const string& s)
    		//{
        
    		//	if (this != &s)
    		//	{
        
    		//		string tmp(s);//拷贝构造
    		//		swap(tmp);
    		//	}
    		//	return *this;
    		//}
    		// 极致写法，效率与上面一样
    		string& operator=(string tmp)//参数直接调用拷贝构造
    		{
        
    			swap(tmp);
    
    			return *this;
    		}
    
    		~string()
    		{
        
    			cout << "~string()" << endl;
    			delete[] _str;
    			_size = _capacity = 0;
    		}
    
    	private:
    		char* _str;
    		size_t _size;//有效存储字符个数
    		size_t _capacity;//实际空间
    	};
    }

[a746a3bdb3db4521a78cc094207f94ed.gif_pic_center]: https://img-blog.csdnimg.cn/a746a3bdb3db4521a78cc094207f94ed.gif#pic_center
[string]: https://cplusplus.com/reference/string/string/?kw=string