string类

string类
- 一、stirng的介绍及使用
- 1.为什么学习string类？
- 2.标准库中的string类
- - 2.1 引入：编码
  - 2.2 basic_string
- 3.string类的使用
- - 3.1 构造函数
  - 3.2 遍历string
  - - 方式1：for循环
    - 方式2：范围for
- 4.迭代器
- - 4.1 正向迭代器
  - 4.2反向迭代器
  - 4.3 const正向迭代器
  - 4.4 const反向迭代器
- 5.容量操作
- - 5.1 string如何实现扩容
  - 5.2 reserve
  - 5.3 resize
- 6.元素获取
- 7.对象数据的修改
- - 7.1 append
  - 7.2 operator+=
  - 7.3 insert
  - 7.4 erase
  - 7.5 assign&replace
- 8.字符串操作
- - 8.1 find
  - 8.2 substr
  - 8.3 rfind
  - 8.4 c_str
- 9.非成员函数
- 二、string的深度剖析及模拟实现
- 1.构造函数
- - 1.1无参构造
  - 1.2直接构造
  - 1.3拷贝构造
  - 1.4析构函数
- 2、字符串的大小
- 3、运算符重载
- - 3.1[ ]重载
  - 3.2赋值重载
- 4、resize和reserve
- - 4.1空间大小调整
  - 4.2修改数据个数
- 5、增删查改
- - 5.1尾插字符
  - 5.2尾插字符串
  - 5.3指定位置插入字符
  - 5.4指定位置插入字符串
  - 5.5删除
  - 5.6查找字符
  - 5.7查找子字符串
- 6、clear
- 7、流插入、流提取
- 三、VS和g++下string结构的说明
- 1、VS下的情况
- 2、g++（Linux）下的情况

一、stirng的介绍及使用

1.为什么学习string类？

C语言中的字符串

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

面试题(暂不做分析)

字符串转整形数字

字符串相加

在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数

2.标准库中的string类

2.1 引入：编码

在计算机语言中，我们了解编码一词，我们最熟知的编码即是ASCII码，其本质即为建立计算机存值与文字符号间的映射关系；

例如：

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "apple";
}

可知我们使用ASCII码的方式表示字母等符号，将其对应的编码存放在内存中

然而我们通过ASCII码仅能解决英语的表示，那世界各国的语言又该以怎样的编码方式表示呢？

即：Unicode——万国码，其中UTF8使用的最为广泛（兼容ASCII码）

而为了针对中文编码，又引入GBK这种编码格式、

2.2 basic_string

表示字符数组时，我们使用基准的类：basic_string，即是因为编码格式的不同，由于utf-8使用的频率很高，因此我们使用string类用的很多，string类的基本框架如下：

由于basic_string不确定字符宽度的大小，因此编写时运用到了模板，其本质是一个动态增长字符数组

template<class T>
class basic_string
{
private:
	T* str;
	size_t _size;
	size_t capacity;
};

注意：basic_string是类模板的类名，不是类型（普通类名即为自定义类型），因此在使用类模板作为类型时需要带上类模板参数，由于我们存的是utf-8的数据，即我们定义类模板参数为char即可：

typedef basic_string<char> string;

3.string类的使用

string类作为C++当中第一个学习的基本类，是非常常用的一个类；并且string比STL产生地早一点；string类有一百多种接口函数(包括函数重载)，但我们只需要学习一些常见的重要的接口即可

头文件：

#include<string>

3.1 构造函数

//无参构造
string s1;             //等价于basic_string<char> string
//带参构造
string s2("hello");
s2 += "world";         //重载

string s3="hello world";
string s4(10,'*');

支持流插入、流提取：

cout<<s1<<endl;
cout<<s2<<endl;
cout<<s3<<endl;
cout<<s4<<endl;

常用构造如下：

(constructor)函数名称	功能说明
string()	构造空的string类对象，即空字符串
string(const char* s)	用C-string来构造string类对象
string(size_t n, char c)	string类对象中包含n个字符c
string(const string&s)	拷贝构造函数

3.2 遍历string

情景引入：将每个字符+1

void test2()
{
    string s1("1234");
}

方式：遍历它

方式1：for循环

下标[ ]——重载，使得它可以像数组一样直接读取和写入

[ ]这里的作用是取第i个位置的字符（底层已重载）

for (size_t i = 0; i < s1.size(); i++)
{
	s1[i]++;
}
cout << s1 << endl;

方式2：范围for

for (auto& ch : s1)
{
	ch--;
}
cout << s1 << endl;

4.迭代器

string类下为我们提供了四种类型的迭代器：

4.1 正向迭代器

关键词：iterator

用法：iterator是一个行为上像指针一样的类型

string::iterator it1 = s1.begin();

iterator是用于string类中的迭代器，因此需要限定类域

可以遍历读写容器数据

string::iterator it1 = s1.begin();
while (it1 != s1.end())
{
	*it1 += 1;
	it1++;
}

这里我们用到了：

其中s1.begin()代表的是第一个有效字符的位置，而s1.end()代表的是最后一个有效字符的下一个位置，因此这串字符用其表示为一个左闭右开的区间；

此时我在思考，迭代器存在的意义是什么呢，我们用最原始的for循环，通过[ ]重载方法也能简单快速实现我们的目标；迭代器的存在即是向我们提供一个通用的访问形式！

4.2反向迭代器

本质与迭代器一样，只是关键字的改变需要注意

可以遍历读写容器数据

string s1("1234");
string::reverse_iterator rit = s1.rbegin();
while (rit != s1.rend())
{
	cout << *rit << " ";
	rit++;
}

结果如下：

4.3 const正向迭代器

const迭代器用于处理const类对象，用法与前述迭代器一致

可以遍历读写容器数据

例：

void Print(const string& s)
{
	string::const_iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		it++;
	}
}

4.4 const反向迭代器

可以遍历读容器数据，但不能修改容器数据

补充：

我们可以发现，很多关于其函数名的重载，都为我们提供的是const与非const两类，其规律我们可以总结如下：

1.只读功能函数：const版本

2.只写功能函数：非const版本

3.读写功能的函数：const+非const版本

5.容量操作

C++提供的有关对string类容量的操作主要如下：

函数名称	功能说明
size (重点)	返回字符串有效字符长度
length	返回字符串有效字符长度
capacity	返回空间总大小
empty (重点)	检测字符串释放为空串，是返回true，否则返回false
clear (重点)	清空有效字符（但不清除这片空间）
reserve (重点)	为字符串预留空间，扩容
resize (重点)	将有效字符的个数改成n个，多出的空间用空字符/指定字符填充

在cplusplus网站具体描述如下：

关于对于长度的描述：size还是length？

我们一般使用size，因为对于string类其字符串我们可以用长度来描述，但是对于以后的链表、栈等数据结果，我们用长度一词来描述显得有点问题；为了实现通用性，我们统一使用size即可

引例：

string s("hello world");
cout << s.size() << endl;
cout << s.length() << endl;
cout << s.capacity() << endl;
cout << s.max_size() << endl;

5.1 string如何实现扩容

实现方式：

void TestPushBack()
{
	string s;
	size_t sz = s.capacity();
	cout << "capacity changed: " << sz << endl;
	cout << "making s grow:" << endl;
	for (int i = 0; i < 1000; i++)
	{
		//尾插字符c
		s.push_back('c');
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed: " << sz << endl;
		}
	}
}

运行如下：（目标空间大小为1000）

可以看出是以大约1.5倍空间的方式扩容到目标大小

由于扩容对资源的开销大（本地扩容、异地扩容），因此若已知大约的空间大小，可以提前开好空间防止扩容造成的资源开销

但是capacity作为一个只读的接口，我们无法直接对其进行修改，因此C++像我们提供了reserve

5.2 reserve

即为：请求使字符串容量适应计划的大小更改为最多 n 个字符；

例如对上述程序加入：

s.reserve(1000);

因此，对于我们已经要插入多少数据，可以使用reserve提前开好空间，避免扩容，提高效率

如果提前开好空间后，若插入数据时容量仍不足，亦会自动扩展空间：

5.3 resize

上述reserve只会改变capacity（开辟的内存空间大小），并不会改变这个字符串的实际容量size

resize的作用是将有效字符数更改为n个，多出的空间用空字符（不可见字符）填充；

引例：

string s("hello world");
cout << s.size() << endl;
cout << s.capacity() << endl;

情况分析：对于resize的n的分析

n<size 删除数据

size<n<capacity 插入数据

n>capacity 扩容+插入数据

void Test()
{
	string s1("hello world");
	s1.resize(5);
	cout << s1.size() << endl;
	cout << s1.capacity() << endl;
	cout << s1 << endl << endl;

	string s2("hello world");
	s2.resize(13);
	cout << s2.size() << endl;
	cout << s2.capacity() << endl;
	cout << s2 << endl << endl;

	string s3("hello world");
	s3.resize(20);
	cout << s3.size() << endl;
	cout << s3.capacity() << endl;
	cout << s3 << endl << endl;
}

结果如下：

用指定字符填充后续n>size的部分：

string s("hello world");
//指定用x来填充后续部分
s.resize(20, 'x');
cout << s.size() << endl;
cout << s.capacity() << endl;
cout << s << endl << endl;

结果如下：

6.元素获取

这一板块很简单，重点即是前两个用法，就不过多赘述

7.对象数据的修改

函数名称	功能说明
`operator+=`	在字符串结尾添加一个字符串或者字符
`append`	追加字符串或者字符
`push_back`	在字符串末尾追加一个字符
`insert`	在pos位置插入一个字符串或者字符
erase	删除pos位置上的字符，或者使用迭代器删除一段字符
replace	字符串拷贝
swap	string对象交换

7.1 append

push_back是尾插入一个字符，当我们要添加一串字符串时使用尾插相对麻烦，因此我们可以使用append来实现对一串字符串的插入

其重载类型非常丰富，具体如下：

👉 [详细用法介绍链接](string::append - C++ Reference (cplusplus.com))

举例如下：

void Test8()
{
	string s1("hello");
	s1.push_back('!');
	s1.push_back(' ');
	s1.append("world");
	cout << s1 << endl;

	string s2("!!!!!!!");
	s1.append(s2);
	cout << s1 << endl;
}

7.2 operator+=

该接口是使用最多的方式，非常的直观

void Test()
{
	string s1("hello");
	string s2("world");
	s1 += s2;
	cout << s1 << endl;
}

7.3 insert

作为一个具有插入功能的接口，它可以为我们提供在任意位置插入字符串的功能，因此可以通过它来实现头插、尾插、中间插入

由于push_back和append是为尾插提供的专门接口，因此insert主要是用于头插和中间插入

void Test()
{
	string s("hello world");
	s.insert(0, "hello");
	cout << s << endl;
	s.insert(5, "!");
	cout << s << endl;
}

7.4 erase

erase，顾名思义即是从指定位置开始删除其后面的字符串，常用的即是指定删除位置、删除个数；如果我们想要删除完这个字符串，即给出大于字符串长度的删除个数或缺省值即可；

需要注意的是pop_back是作为尾删的一个接口，在需要头删或者删除中间位置的时候可以使用erase

void Test()
{
	string s1("hello world");
	//从指定位置开始删除指定个数
	s1.erase(5, 3);
	cout << s1 << endl;

	string s2("hello world");
	//删除完
	s2.erase(5, 10);
	cout << s2 << endl;

	string s3("hello world");
	//给出缺省值：删除完
	s3.erase(5);
	cout << s3 << endl;
}

7.5 assign&replace

assign的作用是赋值，相当于先clear再给予它新的字符串

replace的作用是从指定位置开始，替换指定个数的字符，成目标字符串

void Test12()
{
	string s1("hello world");
	string s2("hello world");

	s1.assign("ok");
	cout << s1 << endl;
	s2.replace(6, 5, "kevin");
	cout << s2 << endl;
}

我们有数据结构的基础即可知道，其底层实现原理是由数组实现的，当替换只后会移动其后续字符，其时间复杂度为O(n^2)，效率很低，因此虽然很方便，但我们并不推荐其使用

例如：将字符串的空格位置替换为"%20"：

void Test()
{
	string s1("hello world hello world");

	int pos = s1.find(' ');
	while (pos != string::npos)
	{
        //使用find
		s1.replace(pos, 1, "20%");
        //从找到的上一个位置pos之后再向后移动三位(20%)开始继续查找
		pos = s1.find(' ', pos + 3);
	}
	cout << s1 << endl;
}

很明显，该段程序时间复杂度方便不是很优秀，因此我们可以采用空间换时间的方式进行优化

void Test13()
{
	string s2("hello world hello world");
	string ret;
	ret.reserve(s2.size());                     //预开空间
	for (int i = 0; i < s2.size(); i++)
	{
		if (s2[i] != ' ')
		{
			ret += s2[i];
		}
		else
		{
			ret += "20%";
		}
	}
	cout << ret << endl;
}

8.字符串操作

函数名称	功能说明
c_str	返回指向string对象值的c-string(C语言字符串)表示形式的指针
find	在对象中查找一个字符或者字符串并返回其下标位置
substr	提取子串，提取从pos位置开始的len个字符，并返回这个字符串对象

8.1 find

find可以从指定位置查找一个字符、查找一串字符串，或者是一个string对象，然而使用find时需要注意它未查到目标时的返回值，具体如下：

理解即是：当未查到指定目标时返回nops，在string类中表现为-1（VS编译器下），但是为了程序的通用性，建议还是直接使用npos表示：

int pos = s1.find("target");
pos != string::npos;             //表示找到了目标字符串

若指定位置给缺省值，那么find默认从0位置开始查找

8.2 substr

substr的作用是提取子串，提取从pos位置开始的len个字符，并返回这个字符串对象

因此可以结合find一同使用，用find确定pos开始的位置，再向后提取

同样的，substr的第二个参数位置可以给出缺省值，那么就默认提取到结尾

下面给出例子：提取文件后缀名

void Test()
{
	string file;
	cin >> file;
	//要求提取后缀
	size_t pos = file.find('.');
	if (pos != string::npos)
	{
        //从pos位置('.')开始提取
		string suffix = file.substr(pos);
		cout << suffix << endl;
	}
}

8.3 rfind

find是从字符串开始依次向后查找，而rfind则是用来从后向前查找

在Linux环境下，文件通常有多个后缀，而最后一个后缀通常才是这个文件的格式，因此在我们需要直接提取最后一个后缀时（最后一个’.'）我们即可采用rfind倒着查找：

void Test14()
{
	string file;
	cin >> file;
	//倒着查找：rfind
	size_t pos = file.rfind('.');
	if (pos != string::npos)
	{
		string suffix = file.substr(pos);
		cout << suffix << endl;
	}
}

8.4 c_str

该接口的作用是返回string对象值的C形式的字符串（表示的形式指针）

例如在C++环境使用C语言的文件操作时：

void Test()
{
	string file("string.cpp");
    //返回string对象值的C形式的字符串：
	FILE* fout = fopen(file.c_str(), "r");
	assert(fout);

	char ch = fgetc(fout);
	while (ch != EOF)
	{
		cout << ch;
		ch = fgetc(fout);
	}
	fclose(fout);
}

即完成文件的读取：

9.非成员函数

二、string的深度剖析及模拟实现

C++向我们提供了string类及其各种接口，而对于我们学习而言，通过自己实现string类为我们提供的各种接口，会让我们更深刻的理解string类

对于string类我们，首先我们要搭建string类的基本框架：

class string
{
public:
	typedef char* iterator;
    //迭代器begin
	iterator begin();
	
    //迭代器end
	iterator end();
		
	//无参构造
	string();

	//直接构造
	string(const char* str);

	//交换
	void swap(string& s);
		
    //深拷贝s2(s1) 
	string(const string& s);
			
	//析构函数
	~string();
		
	//得到字符串（长度）大小
	size_t size() const;
		
	//[]重载：普通对象：可读可写
	char& operator[](size_t pos);
		
	//const对象：只读
	char& operator[](size_t pos) const;
		
	//赋值重载 
	string& operator=(string s);
		
	//空间大小调整
	void reserve(size_t n);
		
	//修改数据个数
	void resize(size_t n, const char ch = '\0');
		
	//插入字符
	void push_back(char ch);
		
	//插入字符/字符串
	void append(const char* str);

	//添加字符
	string& operator+=(char ch);
		
	//添加字符串
	string& operator+=(const char* str);
		
	//在某个位置插入字符
	string& insert(size_t pos, char ch);
	
    //在某个位置插入字符串
	string& insert(size_t pos, const char* str);
		
    //删除
	string& erase(size_t pos, size_t len = npos);

	//查找字符
	size_t find(const char ch, size_t pos = 0);
		
	//查找子字符串
	size_t find(const char* str, size_t pos = 0);
	
    //清空字符串
	void clear();

private:
		char* _str;
		size_t _size;
		size_t _capacity;

		const static size_t npos = -1;
};

对于string类，它的本质是动态增长的数组，因此我们可以像顺序表一样，通过动态开辟一个字符串数组char*，用size控制字符串的长度，而用capacity来表示这个容器的容量大小；

1.构造函数

我们提供无参构造、直接构造、以及拷贝构造（深拷贝）三种构造函数，并提供析构函数

1.1无参构造

无参构造可以理解为创造一个string类的对象并对它进行初始化：

初始化：为’\0’开辟一个空间

string()
{
    _str=new char[1];
    _str[1]='\0';
    _size=_capacity=0;
}

1.2直接构造

可根据传参的方式直接构造出string类对象，由于传入的字符串是不用更改的，因此我们最好加const修饰

string(const char* str)
{
    _size=strlen(str);               //获得字符串，不包含'\0'
    _capacity=_size;                 //cpapcity代表有效字符串容量
    _str=new char[_capacity+1];      //开辟空间大小=容量+1(用于存'\0')
    
    strcpy(_str,str);
}

1.3拷贝构造

若我们不自己提供拷贝构造函数，系统也会默认提供，然而系统为我们提供的是浅拷贝，即两个对象指向同一块空间，显然在自动调用完析构函数后就会出现野指针的问题，因此我们需要自己提供深拷贝构造

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

现代写法：

所谓深拷贝和浅拷贝最大的区别即是空间问题的处理上，因此我们不妨复用拷贝构造造一个临时对象tmp，再让为需要被拷贝的与之swap即可：

swap时需要对其—str、size、capacity三个属性分别交换，因此我们亦可把它们封装到一个函数中：

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

//拷贝构造：现代写法  s2(s1)
string(const string& s)
    :_str(nullptr)
    ,_size(0)
    ,_capacity(0)
{
    string tmp(s._str);   //这里调用了通过字符串直接构造
    //此时tmp和s1一样：同样的空间大小、同样的值
    swap(tmp);
}

1.4析构函数

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

2、字符串的大小

size_t size()
{
    return _size;
}

3、运算符重载

3.1[ ]重载

让string类元素能像数组一样可读可写

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

而对于const类只读对象我们也提供一个[ ]重载

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

3.2赋值重载

当我们构造了两个string类对象后：

string s1("hello");
string s2;
//要想实现：
s2=s1;

即对=操作符重载，首先还是为被赋值对象开辟一个新空间，让它满足与原对象相同的属性（size、str、capacity），再把被赋值对象的原空间删除，让被赋值对象指向这个新空间；

赋值重载（= 操作符重载）需要为被赋值对象重新分配一块新的空间的原因是因为：

避免资源泄露：被赋值对象在之前可能已经分配了一块内存空间，如果直接在原来的空间上修改会导致该内存块的数据被覆盖，从而导致原有的数据丢失。此外，如果赋值对象的空间不足以容纳新的字符串，也需要重新分配一块更大的内存空间。
保持对象语义：在 C++ 中，对象的赋值应该保持对象的语义。如果直接在原有空间上修改，可能会导致对象的行为与预期不符。
可以保证异常安全：如果在原有空间上直接修改，当分配新内存时可能会发生异常，导致内存泄漏，但是如果先分配新内存再将原有内存释放可以保证异常安全。

因此，为了保证代码的正确性和安全性，需要为被赋值对象重新开辟一个空间，将新字符串拷贝进去，然后释放原有的空间，让被赋值对象指向新的空间。

因此代码实现如下：

string& operator=(const string& s)
{
    //不能自己给自己赋值
    if(this!=&s)
    {
        //开空间
        char* tmp=new char[s._capacity+1];
        strcpy(tmp,s._str);
        
        //删除原空间
        delete[] _str;
        
        //指向新空间
        _str=tmp;
        
        //更改size和capacity
        _size=s._size;
        _capacity=s._capacity;
    }
    return *this;
}

这里我们可以复用拷贝构造，用拷贝构造的方式创建一个临时对象tmp，再交换：

//写法2：
string& operator=(const string& s)
{
    //防止两个相同对象赋值
    if(this!=&s)
    {
        string tmp(s);
        swap(tmp);
    }
    return *this;
}

这里我们用了引用传参，若我们直接使用传值传参，直接让传来的参数（要赋值的字符串）与被赋值的交换即可：

string& operator=(string s)
{
    if(this!=&s)
    {
        swap(s);
    }
    return *this;
}

4、resize和reserve

4.1空间大小调整

我们需要一个合理的扩容方式，同时需要保证只扩容不缩容的特点；需要注意的是，我们扩容采取的均为异地扩容

void reserve(size_t n)
{
    //只扩容不缩容
    if(n>_capacity)
    {
        //开空间的大小是指定空间+1，因为要存'\0‘
        char* tmp=new char[n+1];
        strcpy(tmp,_str);
        delete[] _str;
        _str=tmp;
        
        _capacity=n;
    }
}

4.2修改数据个数

在模拟实现string类的resize接口时，n代表调整后的元素个数，而原来的size和capacity分别表示原始字符串的大小和容量。在此基础上，可以有以下三种关系：

n <= size

如果n小于或等于原始字符串的大小（size），则resize不会分配新的内存，仅仅是将字符串截断到n长度，多余的部分被丢弃。

n <= capacity

如果n大于原始字符串的大小（size），但小于等于当前字符串的容量（capacity），则resize会重新分配内存以适应新的大小，但不会增加内存使用量。此时，新分配的空间不一定在当前容量范围内，但是没有增加内存使用量。

n > capacity

如果n大于当前字符串的容量（capacity），则resize会重新分配内存以适应新的大小，并且增加内存使用量。此时，新分配的空间必须比原始容量大，以存储更多的元素。

在任何情况下，如果n超过了字符串的实际大小（即超过了原始size），则新元素将填充在字符串的末尾，不论是否重新分配了内存。

void resize(size_t n,const char ch='\0')
{
    //n>_size:扩容(在后面默认添加'\0')
    if(n>_size)
    {
        reserve(n);
        for(size_t i=_size,i<n;i++)
        {
            _str[i]=ch;
        }
        _size=n;
        _str[_size]='\0';
    }
    //n<_size:删除——更改'\0'位置即可
    else
    {
        {
            _str[n]='\0';
            _size=n;
        }
    }
}

5、增删查改

5.1尾插字符

插入时需要检查空间：是否开了空间，以及空间大小是否需要扩容（我们采用二倍扩容）

void push_back(char ch)
{
    if(_size==_capacity)
    {
        size_t newCapacity=_capacity==0?4:_capacity*2;
        reserve(newCapacity);
    }
    _str[_size]=ch;   //覆盖了原'\0'的位置
    _size++;
    _str[_size]='\0'; //让字符串仍以'\0'结尾
}

5.2尾插字符串

由于不知道插入的字符串长度，因此这里我们就不用2倍扩容了，而是根据插入字符串的长度扩容

void append(const char* str)
{
    size_t len=strlen(str);
    if(_size+len>_capacity)
    {
        reserve(_size+len);
    }
    //拷贝到_str的尾部
    strcpy(_str+_size,str);
    _size+=len;
    
    _str[_size]='\0';
}

5.3指定位置插入字符

根据空间大小决定需要开辟空间后，只用注意一下挪动数据的循环控制即可：

string& insert(size_t pos, char ch)
{
	//检查插入位置合法性：要算上'\0'
	assert(pos <= _size);
	if (_size == _capacity)
	{
		size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newCapacity);
	}
	//挪动数据
	//防止隐式类型转换
	size_t end = _size + 1;
	while (end > pos)
	{
		_str[end] = _str[end - 1];
		end--;
	}
	_str[pos] = ch;
	_size++;
	return *this;
}

5.4指定位置插入字符串

根据插入字符串长度大小扩容后，将插入位置之后的子字符串向后移动len个位置，由于strcpy会将’\0’拷贝过去，因此我们采用strncpy防止将’\0’拷贝原字符串（此时’\0’处于字符串中间会出问题）

string& insert(size_t pos, const char* str)
{
	//检查插入位置合法性：要算上'\0'
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}

	size_t end = _size + len;
	while (end >= pos + len)
	{
		_str[end] = _str[end - len];
		end--;
	}
	//小心strcpy会将'\0'拷贝过去
	strncpy(_str + pos, str, len);
	_size += len;

	return *this;
}

5.5删除

我们参考原string类，它为我们提供了npos：

在C++的string类中，npos是一个静态成员变量，它表示一个字符串中不存在的位置。在标准库的实现中，npos被定义为一个常量，它的值通常是-1或者std::string::size_type(-1)。

我们在属性中即定义了这个静态成员变量：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LZyuwQyx-1679738886466)(E:\Typora图片\image-20230325152954947.png)]

因此若给出缺省值时会默认使len=npos代表删除pos后的所有字符；

string& erase(size_t pos, size_t len = npos)
{
	//全删的情况
	if (len == npos || pos + len >= _size)
	{
		//不用数据覆盖，只用将'\0'移到删除位置即可
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		strcpy(_str + pos, _str + len + pos);
		_size -= len;
	}
	return *this;
}

5.6查找字符

//pos代表开始查找的位置，若调用时给出缺省值则默认从0位置开始
size_t find(const char ch, size_t pos = 0)
{
	assert(pos < _size);
	while (pos < _size)
	{
		if (_str[pos] == ch)
		{
			return pos;
		}
		pos++;
	}
	return npos;
}

5.7查找子字符串

查找子字符串有一种广为人知的方法：KMP算法，但由于其实现难度大，我们没必要这么做，用库中的strstr字符串查找函数即可：

需要注意的是，strstr返回的是子字符出在内存中的地址，而我们需要返回的是在_str数组中的位置，因此我们需要计算出它们的相对位置即可：

ptr-_str;

具体实现如下：

size_t find(const char* str, size_t pos = 0)
{
	assert(pos < _size);
	const char* ptr = strstr(_str + pos, str);
	if (ptr == nullptr)
	{
		return npos;
	}
	else
	{
		//相对位置ptr是其在内存中的地址
		return ptr - _str;
	}
}

6、clear

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

7、流插入、流提取

由于输入流和输出流是C++中的类，而运算符重载只能在类内或者作为全局函数进行，所以我们需要将插入运算符和提取运算符定义为全局函数。这样就能够方便地在需要输出或输入数据时使用插入运算符和提取运算符进行操作

在C++中，流插入和提取运算符必须以全局函数的形式重载，而不能作为类成员函数的原因：若流插入和提取运算符作为类的成员函数，那么在使用时需要直接访问类的私有成员变量，这会破坏类的封装性，使得类的实现细节暴露在外部，增加了代码的耦合性和可维护性的难度。

对于某些需要访问类的私有成员变量时（例如data类），可以将流插入、流提取定义为该类的友元函数

总结：它必须是全局的,但不一定必须是友元的

//流插入
ostream& operator<<(ostream& out, const string& s)
{
	for (size_t i = 0; i < s.size(); i++)
	{
		out << s[i];
	}
	return out;
}

//流提取
istream& operator>>(istream& in, string& s)
{
	//防止提取前该对象已存字符串,因此先清除
	s.clear();
	char buff[128] = { '\0' };
	size_t i = 0;
	char ch = in.get();
	while (ch != ' ' && ch != '\n')
	{
		//+=会涉及到多次扩容
		//s += ch;
		//因此用到一段一段的进入s
		if (i == 127)
		{
			//满了，128位留给'\0'
			s += buff;
			i = 0;
		}
		buff[i] = ch;
		i++;
		//继续读取字符
		ch = in.get();
	}
	//防止还有一段没有加入
	if (i >= 0)
	{
		buff[i] = '\0';
		s += buff;
	}
	return in;
}

在函数内部，首先通过调用string对象的clear()函数清空原有的字符串，然后使用一个char类型的数组buff来缓存读取到的字符。在while循环中，读取输入流中的字符，如果该字符不是空格或换行符，则将其存储到缓存数组buff中，并递增i，同时继续读取下一个字符。当缓存数组已经存储满128个字符时，将其追加到string对象中，i重新赋值为0。最后，将剩余的字符添加到缓存数组中，并将其存储到string对象中。

需要注意的是，这里使用一个缓存数组是为了避免使用s += ch的方式来逐个字符添加到string对象中，因为这样的方式可能会涉及到多次扩容，导致性能降低。而将读取到的字符暂存在一个缓存数组中，一次性追加到string对象中，能够提高程序的执行效率。

三、VS和g++下string结构的说明

1、VS下的情况

引例：

void test()
{
	string s1("1234");
	string s2("abcdefghijklmnopqrstuvwxyz");

	cout << sizeof(s1) << endl;
	cout << sizeof(s2) << endl;
}

s1和s2的大小相同：数据并没有存到对象上，而是存入对应指向的空间上：

为什么大小是40？

在VS编译器下还给string类添加了一个属性buff：

private:
	char buff[28];     //类对象大小为40，40-3*4=28
	char* _ptr;
	size_t _size;
	size_t _capacity;

buff为能存28个字节大小的数组（VS2022下）

当数据量小于28时，数据存于buff中（s1），而当数据量大了后，即存入原始开辟的数组空间中：

buff的存在本质是一种以空间换时间的设计思想：

< buff 存在buff中

> buff存在_ptr指向的空间

2、g++（Linux）下的情况

G++下， string是通过写时拷贝实现的， string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段：

①空间总大小
②字符串有效长度
③引用计数

写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。

引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。

C++中的string类【详细分析及模拟实现】

string类

目录

一、stirng的介绍及使用

1.为什么学习string类？

2.标准库中的string类

2.1 引入：编码

2.2 basic_string

3.string类的使用

3.1 构造函数

3.2 遍历string

方式1：for循环

方式2：范围for

4.迭代器

4.1 正向迭代器

4.2反向迭代器

4.3 const正向迭代器

4.4 const反向迭代器

5.容量操作

5.1 string如何实现扩容

5.2 reserve

5.3 resize

6.元素获取

7.对象数据的修改

7.1 append

7.2 operator+=

7.3 insert

7.4 erase

7.5 assign&replace

8.字符串操作

8.1 find

8.2 substr

8.3 rfind

8.4 c_str

9.非成员函数

二、string的深度剖析及模拟实现

1.构造函数

1.1无参构造

1.2直接构造

1.3拷贝构造

1.4析构函数

2、字符串的大小

3、运算符重载

3.1[ ]重载

3.2赋值重载

4、resize和reserve

4.1空间大小调整

4.2修改数据个数

5、增删查改

5.1尾插字符

5.2尾插字符串

5.3指定位置插入字符

5.4指定位置插入字符串

5.5删除

5.6查找字符

5.7查找子字符串

6、clear

7、流插入、流提取

三、VS和g++下string结构的说明

1、VS下的情况

2、g++（Linux）下的情况

相关文章