当前位置： 首页 > article >正文

STL之string

article 2025/3/31 9:30:08

1.为什么学习string类

1.1 C语言中的字符串

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

1.2 笔试面试题

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

2.标准中的string类

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

注意：在使用string类时，必须包含#include头文件以及using namespace std;

#include<string>
using namespace std;

2.2 string类的常用接口说明

1. string类对象的常用构造

构造函数

（constructor）函数名称功能说明
string()（重点）构造空的string类对象，即空字符串
string(const char* s)（重点）用C-string来构造string类对象
string(size_t n, char c)string类对象中包含n个字符c
string(const string& s)（重点）拷贝构造函数
//string管理动态增长的字符数组，这个字符传以\0结尾以兼容C语言
int main()
{
	string s1;//1.无参构造空字符串
	string s2("hello world");//2.带参构造函数：用C—string来构造string类对象，当然，此处还有下面的一种形式
    
    char str[] = "hello world";
    string s2(str);//这个地方发生了类型转换，str的类型是char*，然后被转换成了const char*
    
    string s3(s2);//3.拷贝构造函数：形式1
    string s3 = s2;//3.拷贝构造函数：形式2
    
    string s4(10, 'c');//4.string类对象中包含10个'c'
	return 0;
}

除了上述几个常用的之外，还有几个不是特别常用的，仅作了解：

//形式：string(const char* s, size_t n);(用字符串s的前n个字符构成的字符串来对字符串进行构造)
string s1("hello world", 5);//相当于string s1("hello");//"hello"是"hello world"的前5个字符形成的字符串
//形式：string (const string& str, size_t pos, size_t len = npos);(用从str的pos位置开始的len个字符形成的字符出啊来对字符串进行构造,npos有一个缺省值（static const size_t类型），是-1，所以当npos缺省的时候就是将从pos位置开始的字符一直到最后一个字符全部都用来对字符串进行构造)
string s1("hello world");
string s2(s1, 4, 5);//用从o开始的5个字符形成的字符串来对s2字符串进行构造，即o wor
//注意：当pos + npos超出字符串长度的时候，就会把从pos开始的所有字符串都拿来对s2进行初始化

析构函数

image-20220603120926569

因为string类型是动态管理的，如果不需要使用了就需要去主动给释放，所以有了string类的析构函数。

注意：string类型的析构函数是自动调用的，不需要去手动调用，出了作用域自动销毁。

赋值运算符重载

image-20220603121426632

使用举例：

string s1("hello");
string s2("world");
s1 = s2;//第一种形式：最常用
s1 = "world";//第二种形式
s1 = 'H';//第三种形式

2. string类对象的容量操作

函数名称功能说明
size返回字符串有效字符长度（不包含’\0’）（常用）
length返回字符串有效字符长度（不包含’\0’）（不常用）
capacity返回空间总大小（数据不一定，但一定>=size）
empty检测字符串是否为空串，是返回true，否则返回false
clear清空有效字符
reserve为字符串预留空间（改变的只是capacity，因为内存对齐现象，实际的capacity可能会略大但不会小于预留的空间）注意：reserve支持扩容，但是不能缩小空间且无法修改size和capacity；而且没有对扩容的空间进行初始化（开空间）（VS2019下不能缩）
resize将有效字符的个数该成n个，多出的空间用字符c填充。注意：resize不仅仅会改变capacity，还会改变size；resize同样也无法缩小空间但是resize能够修改size不能修改capacity；扩容时的位置初始化为’\0’（开空间+初始化）（VS2019下不能缩）

使用举例：

// size/clear/resize
void Teststring1()
{
	// 注意：string类对象支持直接用cin和cout进行输入和输出
	string s("hello world!!!");
	cout << s.size() << endl;//输出结果为11
	cout << s.length() << endl;//输出结果为11
	cout << s.capacity() << endl;//输出结果为一个大于11的数字

	// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
	s.clear();
	cout << s.size() << endl;//输出结果为0
	cout << s.capacity() << endl;//输出结果为0
    cout << s << endl;//输出结果为空
    
	// 将s中有效字符个数增加到10个，多出位置用'a'进行填充
	// “aaaaaaaaaa”
	s.resize(10, 'a');
	cout << s.size() << endl;//输出结果为10
	cout << s.capacity() << endl;//输出结果为一个大于10的数据
    
	// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充
	// "aaaaaaaaaa\0\0\0\0\0"
	// 注意此时s中有效字符个数已经增加到15个
	s.resize(15);
	cout << s.size() << endl;//输出结果为15
	cout << s.capacity() << endl;//输出结果不变
	cout << s << endl;//输出结果为aaaaaaaaaa
    
	// 将s中有效字符个数缩小到5个，capacity并没有改变，size被改变了
	s.resize(5);
	cout << s.size() << endl;//输出结果为5
	cout << s.capacity() << endl;//输出结果没有改变
	cout << s << endl;//输出结果为aaaaa
}
//================================================================================
====
void Teststring2()
{
	string s;
	// 测试reserve是否会改变string中有效元素个数
	s.reserve(100);
	cout << s.size() << endl;//输出结果为0
	cout << s.capacity() << endl;//输出结果为一个大于100的数据
	// 测试reserve参数小于string的底层空间大小时，是否会将空间缩小
	s.reserve(50);
	cout << s.size() << endl;//输出结果为0
	cout << s.capacity() << endl;//输出结果不变
}
// 利用reserve提高插入数据的效率，避免增容带来的开销（在VS下扩容大概是1.5倍左右）
//================================================================================
====
void TestPushBack()
{
	string s;
	size_t sz = s.capacity();
	cout << "making s grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}
void TestPushBackReserve()
{
	string s;
	s.reserve(100);//一开始就设定一个容量（size并没有被改变），就不存在扩容了，避免了扩容消耗，因为存在对齐现象，并不会严格的一致，可能稍微大于我们设定的容量
	size_t sz = s.capacity();

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

其它关于容量的操作：

函数名称功能说明
max_size返回字符串的最大长度（基本用不到）

注意：

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

3. string类对象的访问及遍历操作

函数名称功能说明
operator[]返回pos位置的字符，const string类对象调用，注意返回的是引用，可以通过返回值来对原字符串进行修改
begin+endbegin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭 代器
rbegin+rendbegin获取一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器
范围forC++11支持更简洁的范围for的新遍历方式

使用举例：

int main()
{
    string str("hello");
	//遍历string中的每一个字符
	//第一种方式：下标 + []法
	for (size_t i = 0; i < str.size(); i++)
	{
		cout << str[i] << " ";
		//相当于是调用下面的函数
		//cout << str.operator[](i) << " ";
	}
	//第二种方式：迭代器（像指针一样的东西或者就是指针，看底层的具体实现）
	//注意：//end不指向最后一个数据，指向最后一个有效数据的下一个位置，在string中是'\0'，即[)，左闭右开区间
	string::iterator it = str.begin();//iterator是string类中定义的，是string的内嵌类型
	while (it != str.end())//如果要遍历的是数据是连续存储的物理空间，可以用<，如果不是连续存储的，就必须用!=
	{
		cout << *it << " ";
		it++;
	}
	//第三种方式：范围for（实际会被替换成迭代器）
	for (auto& i : str)
	{
		cout << i << " ";
	}
}

反向迭代器与const迭代器

反向迭代器：

作用：反向迭代器可以对字符串进行倒序遍历访问。

image-20220603160430911

作用：rbegin指向最后一个有效字符。

image-20220603160451172

作用：rend指向第一个字符的前一个位置。

使用举例：

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

运行结果：

image-20220603160833252

常迭代器：

作用：常迭代器用来对const类型的字符串进行遍历访问。因为普通的迭代器具有可读可写的权限，但是常迭代器只具有可读的权限。

下面是一种方式：

方法一：（C++11，不常用）

image-20220603161855786

image-20220603162209923

image-20220603162646773

string::const_iterator cIt = s1.cbegin;
string::const_iterator cIt = s1.cend();
string::const_reverse_iterator It = s1.crbegin();
string::const_reverse_iterator It = s1.crend();

方法二：（一般用这个）

image-20220603162744391

image-20220603162815478

使用举例：

string::const_iterator cIt = s1.begin;
string::const_iterator cIt = s1.end();
string::const_reverse_iterator It = s1.rbegin();
string::const_reverse_iterator It = s1.rend();

遍历字符串的例题：

image-20220603150950788

代码：

//方法一：下标的方法
class Solution {
public:
	bool isLetter(char ch)
	{
		if (ch >= 'a' && ch <= 'z')
			return true;
		else if (ch >= 'A' && ch <= 'Z')
			return true;
		else
			return false;
	}
	string reverseOnlyLetters(string s) {
        size_t left = 0;
        size_t right = s.size() - 1;
        while(left < right)
        {
            while(left < right && !isLetter(s[left]))
            {
                left++;
            }
            while(left < right && !isLetter(s[right]))
            {
                right--;
            }
            swap(s[left],s[right]);
            left++;
            right--;
        }
		return s;
	}
};
//方法二：迭代器的方法
class Solution {
public:
	bool isLetter(char ch)
	{
		if (ch >= 'a' && ch <= 'z')
			return true;
		else if (ch >= 'A' && ch <= 'Z')
			return true;
		else
			return false;
	}
	string reverseOnlyLetters(string s) {
        string::iterator left = s.begin();
        string::iterator right = s.end() - 1;
		while (left < right)
		{
			//cout<<left<<":"<<right<<endl;
			while (left < right && !isLetter(*left))
				++left;

			while (left < right && !isLetter(*right))
				--right;

			swap(*left, *right);
			++left;
			--right;
		}

		return s;
	}
};

问：此处为什么只需要一个swap就能对两个字符串对应位置的字符进行交换呢？

答：因为C++编译器默认提供了swap函数，如下图所示：

image-20220603152116359

通过函数模板的实现，可以通过swap函数来交换任意类型的两个数据。

一些其它的遍历访问方式

  • at

    image-20220603154536355

    也是访问字符串pos位置处的字符，和[]的作用基本一致，使用举例：

    string s1("hello");
s1.at(0) = 'y';//将字符串第一个位置处的字符即h修改为y

    注意：at和[]的区别在于越界访问。

    []:

    image-20220603155158020

    []在越界的时候会引起未定义的行为（在VS2019的情况下是断言）。

    at:

    image-20220603155117783

    at在越界的时候会引发异常。

  • back和front

    image-20220603155819260

    image-20220603155848787

    作用：back是返回最后字符串的最后一个字符，front是返回第一个字符。

    使用举例：

    string s1("hello");
cout << s1.front() << s1.back() << endl;//打印结果为ho

4. string类对象的修改操作

函数名称功能说明
push_back在字符串后尾插字符c
append在字符串后追加一个字符串
operator+=(重点)在字符串后追加字符串str
c_str(重点)返回C格式字符串
find+npos(重点)从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
substr在str中从pos位置开始，截取n个字符，然后将其返回
insert在字符串的某个位置或迭代器位置插入一个字符或者字符串
erase删除字符串某个位置的字符
assign字符串之间进行赋值
swap两个字符串之间进行交换

详细了解push_back

image-20220628191711868

代码练习：

int main()
{
	string s1 = "hello world";
	s1.push_back('c');//在字符串s1的后面添加字符'c'
    //添加后字符串s1变成了"hello worldc"
	return 0;
}

详细了解append

image-20220628191840067

代码练习：

int main()
{
	string s1 = "hello ";
	string s2 = "world";
	s1.append(s2);//在字符串s1的后面添加字符串s2，添加后字符串s1变成了"hello world"
	
	s1 = "hello ";
	s2 = "world";
	s1.append(s2, 3, 2);//在字符串s1的后面添加字符串s2从第三个字符开始的2个字符组成的字符串即"ld"，此时s1变成了"hello ld"
	
	s1 = "hello ";
	s1.append("world");//在字符串s1的后面添加字符串"world"

	return 0;
}

详细了解c_str

image-20220628194325687

代码练习：

int main()
{
	string s1 = "hello world";
	const char* str = s1.c_str();//返回指向string类型的s1中存储"hello world"首字符的地址
    cout << s1 << endl;//调用的是字符串类型的运算符重载
    cout << str << endl;//调用的也是运算符重载，不过针对的是char* 类型的运算符重载
    //上述两种方式都能够正确打印出"hello world"
	return 0;
}

详细了解find和rfind

image-20220628194805469

image-20220628194822841

image-20220628194859363

详细了解substr

image-20220628200628834

代码练习：

//要求取出文件的后缀
int main()
{
	string file = "file.cpp";
	size_t pos = file.find('.');
	if (pos != string::npos)
	{
        string suffix = file.substr(pos, str.size() - pos);
		cout << suffix << endl;//substr的第二个参数默认是无符号整数的最大值
        //substr是返回从pos开始的len个字符组成的string类型的字符串
	}
	else
	{
		cout << "不存在后缀" << endl;
	}

	return 0;
}

此时需要考虑一种情况，当文件名为file.c.tar.zip时我们该如何拿到该文件名的后缀.zip呢？

代码练习：

int main()
{
	string file = "file.cpp";
	size_t pos = file.rfind('.');//倒着找即可
	if (pos != string::npos)
	{
        string suffix = file.substr(pos, str.size() - pos);
		cout << suffix << endl;//substr的第二个参数默认是无符号整数的最大值
        //substr是返回从pos开始的len个字符组成的string类型的字符串
	}
	else
	{
		cout << "不存在后缀" << endl;
	}

	return 0;
}

了解find的扩展

image-20220628201734996

image-20220628201957718

用法和前面的find相类似，不过find_first_of是找到第一个c字符的位置的字符的下标，find_last_of是返回最后一个c字符的位置的字符的下标，find_first_not_of是找到第一个非c字符的位置的字符的下标，find_last_not_of是返回最后一个非c字符的位置的字符的下标。

find的应用场景：找到url中的协议、域名、uri

int main()
{
	string url1("https://www.cnblogs.com/tfknight/p/12793248.html");
	//协议 域名 uri
	string& url = url1;
	string protocol;//协议
	size_t pos1 = url.find("://");
	if (pos1 != string::npos)
	{
		protocol = url.substr(0, pos1);
		cout << "protocol:" << protocol << endl;
	}
	else
	{
		cout << "非法url" << endl;
	}
	string domain;//域名
	size_t pos2 = url.find('/', pos1 + 3);//从w位置开始找
	if (pos2 != string::npos)
	{
		domain = url.substr(pos1 + 3, pos2 - (pos1 + 3));
		cout << "domain:" << domain << endl;
	}
	else
	{
		cout << "非法url" << endl;
	}
	string uri = url.substr(pos2 + 1);
	cout << "uri:" << uri << endl;
	return 0;
}

详细了解insert

image-20220626134307683

代码练习：

int main()
{
	string s1("world");
	s1.insert(0, "hello ");//在字符串s1的首字符处插入一个字符串"hello "，此时s1变成"hello world"
	cout << s1 << endl;

	s1.insert(0, 1, 'x');//在字符串s1的第一个字符处插入一个字符'x'，此时字符串变成了"xhello world"
	cout << s1 << endl;

	s1.insert(s1.begin(), 1, 'y');//在字符串s1的第一个位置处，插入一个字符'y'，此时字符串s1变成了"yxhello world"
	cout << s1 << endl;

	s1.insert(3, 1, 'x');//在字符串s1的第三个位置处插入一个字符'x'，此时字符串s1变成了"yxhxello world"
	cout << s1 << endl;

	s1.insert(s1.begin() + 3, 1, 'y');//在字符串s1的第三个位置处插入一个字符'y'，此时字符串s1变成了"yxhyxello world"
	cout << s1 << endl;

	return 0;
}

打印结果：

image-20220626163755236

详细了解erase

image-20220626164953158

符号解释：

image-20220628184225914

代码练习：

int main()
{
	string s1("hello world");
	s1.erase();//默认pos是0，len是npos，即无符号整数的最大值
	cout << s1 << endl;
	string s2 = "hello world";
	s2.erase(3);//删除从第三个字符往后的所有字符
	cout << s2 << endl;
	string s3 = "hello world";
	s3.erase(3, 2);//删除从第三个字符向后的两个字符
	cout << s3 << endl;
	return 0;
}

运行截图：

image-20220628184127947

详细了解assign

image-20220628184423367

代码练习：

int main()
{
	string s1 = "hello world";
	string s2 = "hahaha";
	s1.assign(s2);//将s2赋值给s1
	cout << s1;
	return 0;
}

详解swap

image-20220628185309801

库里的swap:

image-20220628190219973

本质上是通过拷贝构造和赋值实现了，使用了深拷贝。

代码练习：

int main()
{
	string s1 = "hello world";
	string s2 = "hahaha";
	s1.swap(s2);//效率比较高，本质就是交换指针
	swap(s1, s2);//效率比较低，本质是一种深拷贝
	cout << s1 << endl << s2 << endl;
	return 0;
}

5. string类对象的非成员函数

函数功能说明
operator+尽量少用，因为传值返回，导致深拷贝效率低
operator>>(重点)输入运算符重载
operator<<(重点)输出运算符重载
getline(重点)获取一行字符串
relational operators大小比较
stoi字符串转整型
to_string将各种对象转换为string类型的对象

详细了解getline

image-20220629071422275

注意：getline只有当遇到换行符的时候才会停止输入，而cin遇到空格、换行、tab键时都会停止输入。

详细了解stoi

image-20220715204554421

详细了解to_string

image-20220715204703843

6. 牛刀小试

1.找字符串中第一次只出现一次的字符

image-20220628221736809

代码：

class Solution {
public:
    int firstUniqChar(string s) {
        int count[26] = {0};
        for(auto e : s)
        {
            count[e - 'a']++;
        }
        for(size_t i = 0; i < s.size(); i++)
        {
            if(count[s[i] - 'a'] == 1)
            {
                return i;
            }
        }
        return -1;
    }
};
2.字符串最后一个单词的长度

image-20220629063837089

代码：

#include<iostream>
using namespace std;
int main()
{
    string str;
    getline(cin, str);
    size_t pos = str.rfind(' ');
    if(pos != string::npos)
    {
        cout << str.size() - pos - 1;
    }
    else
    {
        cout << str.size();
    }
    
    return 0;
}

注意：cin当遇到空格，tab，换行时都会停止进行输入，但是geiline只有当遇到换行符时才会 停止输入。

3.字符串相加

image-20220629072951103

代码：

class Solution {
public:
    string addStrings(string num1, string num2) {
        int end1 = num1.size() - 1;
        int end2 = num2.size() - 1;
        int carry = 0;
        string ret;
        while(end1 >= 0 || end2 >= 0 || carry == 1)//carry == 1是为了防止最后只剩一个进位的时候，即"1" + "9" = "10"的这种情况
        {
            int value1 = 0;
            int value2 = 0;
            value1 = end1 >= 0 ? num1[end1] - '0' : 0;
            value2 = end2 >= 0 ? num2[end2] - '0' : 0;
            int tmp = value1 + value2 + carry;//tmp用来临时存储相加的值
            if(carry == 1)//如果上一次的进位为1就将其置为0
            {
                carry = 0;
            }
            if(tmp > 9)
            {
                tmp %= 10;
                carry += 1;
            }
            ret.push_back(tmp + '0');
            end1--;
            end2--;
        }
        reverse(ret.begin(), ret.end());//将字符串进行逆置
        return ret;
    }
};

2.3 关于string的大小问题

环境：Windows下的VS2019环境下：

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string s1("1111111111");
	string s2("2222222222222222222222222222222222222222222");
	cout << "sizeof(s1):" << sizeof(s1) << endl;
	cout << "sizeof(s2):" << sizeof(s2) << endl;

	return 0;
}

输出结果：

image-20220803115448553

class string
{
private:
    char _buf[16];//小于16字节的字符串，直接存到buf中
    char* _ptr;//大于等于16字节的字符串，存在_ptr指向的空间中
    //注意：二者存放是只能选择其一的，即我们想要存储的字符串，要么存放到_buf中，要么存放到_ptr指向的空间中
    size_t _size;
    size_t _capacity;
}

image-20220803115910073

image-20220803120524965

3. string类的模拟实现

3.1 浅拷贝与深拷贝

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

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

image-20220716120226096image-20220716115932803

3.2 string的模拟实现

class mystring
{
public:
	typedef char* iterator;
	typedef const char* const_iterator;
    //普通迭代器的实现
	iterator begin()
	{
		return _str;
	}
    
    iterator end()//返回最后一个有效字符的下一个位置
	{
		return &_str[_size];
		//return _str + _size;
	}
    //const迭代器的实现
	const_iterator begin() const
	{
		return _str;
	}

	const_iterator end()const
	{
		return &_str[_size];
	}
	//构造函数
	mystring(const char* str = "")
		:_size(strlen(str))
		,_capacity(_size)
	{
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}
	//拷贝构造函数
	mystring(const mystring& s)
		:_size(strlen(s._str))
		,_capacity(_size)
	{
		_str = new char[_capacity + 1];
		strcpy(_str, s._str);
	}

	//析构函数
	~mystring()
	{
		if (_str)
		{
			delete[]_str;
			_str = nullptr;
			_size = _capacity = 0;
		}
	}
	//c_str函数
	const char* c_str()const
	{
		return _str;
	}
	//[]运算符重载
	char& operator[](size_t pos)
	{
		assert(pos < strlen(_str));
		return _str[pos];
	}
    //const对象的[]运算符重载
	const char& operator[](size_t pos) const
	{
		assert(pos < strlen(_str));
		return _str[pos];
	}
    //赋值运算符重载
	mystring& operator=(const mystring& s)
	{
		if (&s != this)//防止s1 = s1这种情况
		{
			char* tmp = new char[strlen(s._str) + 1];
			strcpy(tmp, s._str);
			delete[] _str;//不先释放_str是为了防止空间开失败的情况
			_str = tmp;
			_size = s._size;
			_capacity = s._capacity;
		}
		return *this;
	}
    //push_back()函数模拟
	void push_back(char ch)
	{
		if (_capacity == _size)
		{
			reserve(_capacity == 0 ? 4 : 2 * _capacity);
		}

		_str[_size++] = ch;
		_str[_size] = '\0';
	}
    //+=运算符重载
	mystring& operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}
    //+=运算符重载
	mystring& operator+=(const char* str)
	{
		append(str);
		return *this;
	}
    //+=运算符重载
	mystring& operator+=(const mystring& s)
	{
		append(s.c_str());
		return *this;
	}
    //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 = '\0')
	{
		if (n > _capacity)
		{
			reserve(n);
			for (size_t i = _size; i < n; i++)
			{
				push_back(ch);
			}
			_size = n;
			_str[_size] = '\0';
		}
		else
		{
			_str[n] = '\0';
			_size = n;
		}
	}
    //append()函数模拟实现
	void append(const char* str)//也可复用insert
	{
		size_t len = strlen(_str) + strlen(str);
		if (len > _capacity)
		{
			reserve(len);
		}
		strcpy(_str + _size, str);
		_size = len;
	}
    //insert()函数（插入字符）模拟实现
	mystring& insert(size_t pos, char ch)//push_back就是尾插所以可以复用insert
	{
		assert(pos <= _size);
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		size_t end = _size + 1;//因为end是无符号数，所以不能让end为-1
		while (end > pos)
		{
			_str[end] = _str[end - 1];
			--end;
		}
		_str[pos] = ch;
		_size++;
		return *this;
	}
    //insert()函数（插入字符串）模拟实现
	mystring& insert(size_t pos, const char* str)
	{
		assert(pos <= _size);
		size_t len = strlen(str);
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity * 2);
		}
		size_t end = _size + len;
		while (end > pos + len - 1)//注意：while(end >= pos + len)，当pos和len都是0的时候就会出现死循环
		{
			_str[end] = _str[end - len];
			--end;
		}
		strncpy(_str + pos, str, len);
		_size += len;
		return *this;
	}
	//size函数
	size_t size() const
	{
		return strlen(_str);
	}
    //capacity()函数模拟实现
	size_t capacity() const 
	{
		return _capacity;
	}
    //erase()函数模拟实现
	mystring& erase(size_t pos, size_t len = npos)
	{
		assert(pos < _size);
		if (len == npos || pos + len >= _size)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			size_t begin = pos + len;
			while (begin <= _size)
			{
				_str[begin - len] = _str[begin];
				++begin;
			}
			_size -= len;
		}
		return *this;
	}
    //find()函数模拟实现（查找一个字符）
	size_t find(char ch, size_t pos = 0)
	{
		for (; pos < _size; ++pos)
		{
			if (_str[pos] == ch)
			{
				return pos;
			}
		}
		return npos;
	}
    //find()函数模拟实现（查找一个字符串）
	size_t find(char* ch, size_t pos = 0)
	{
		const char* p = strstr(_str + pos, ch);
		if (p == nullptr)
		{
			return npos;
		}
		else
		{
			return p - _str;
		}
	}
    //clear()函数模拟实现
	void clear()
	{
		_str[0] = '\0';
		_size = 0;
	}
private:
	char* _str;
	size_t _size;
	size_t _capacity;
	const static size_t npos;
};
const size_t mystring::npos = -1;
//各种运算符重载
bool operator<(const mystring s1, const mystring s2)
{
	return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const mystring s1, const mystring s2)
{
	return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator<=(const mystring s1, const mystring s2)
{
	return s1 < s2 || s1 == s2;
}
bool operator>(const mystring s1, const mystring s2)
{
	return !(s1 <= s2);
}
bool operator>=(const mystring s1, const mystring s2)
{
	return !(s1 < s2);
}
bool operator!=(const mystring s1, const mystring s2)
{
	return !(s1 == s2);
}
//流插入运算符重载
std::ostream& operator<<(std::ostream& out, const mystring& s)
{
	for (auto e : s)
	{
		out << e;
	}
	return out;
}
//流提取运算符重载（第一种实现方式）
std::istream& operator>>(std::istream& in, mystring& s)
{
	s.clear();
	char ch;
	ch = in.get();
	while (ch == ' ' || ch == '\n')
	{
		s += ch;
		ch = in.get();
	}
	return in;
}
//流提取运算符重载（第二种实现方式）（推荐）
std::istream& operator>>(std::istream& in, mystring& s)
{
	s.clear();
	char ch;
	ch = in.get();
	char buff[128] = { '\0' };
	size_t i = 0;
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;
		if (i == 127)
		{
			s += buff;
			memset(buff, '\0', 128);
			i = 0;
		}
		ch = in.get();
	}
	s += buff;
	return in;
}

上面的是传统的string模拟实现，下面的是现代string的模拟实现：

void swap(mystring& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}
//现代拷贝构造函数写法
mystring(const mystring& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	mystring tmp(s._str);
	swap(tmp);
}

图示：

image-20220716131127059

//比较繁琐的写法
mystring& operator=(const mystring& s)
{
	if (this != &s)
	{
		mystring tmp(s._str);
		swap(tmp);
	}
	return *this;
}
//更简洁的赋值运算符重载(推荐)
mystring& operator=(mystring s)//s是s1的一份临时拷贝，调用了拷贝构造函数
{
	swap(s);
	return *this;
}
//问：这里为什么不需要判断自己给自己赋值？
//答：当自己给自己进行赋值的时候，就是将原来的数据进行一次深拷贝，即挪动了一x

http://www.kler.cn/a/611465.html

相关文章：

  • 鸿蒙 一多适配/屏幕适配/设备适配/分栏
  • Java共享自习室系统全方位技术解析与实战搭建指南
  • C++：函数（通识版）
  • Ansys Zemax | 联合Speos实现供应商与OEM交换黑盒光学系统
  • AI编程工具-（九）
  • 双指针---《移动零》
  • 洛谷题单1-B2002 Hello,World!-python-流程图重构
  • Linux一步部署主DNS服务器
  • 音视频新人如何快速上手nginx-rtmp-module
  • 【C++指针】搭建起程序与内存深度交互的桥梁（上）
  • 美亚科技业绩波动明显：现金流为负，四起未决诉讼涉金额1700万
  • OpenEuler linux samba部分目录无法访问的问题
  • 云服务器 ECS服务器终端安装及配置mysql数据库
  • QT6使用Mysql全流程
  • 冠珠瓷砖×郭培：当东方美学邂逅匠心工艺，高定精神如何重塑品质生活？
  • 汽车制造数字化
  • vscode正则表达式使用
  • （UI自动化测试web端）第三篇：元素的常用操作方法_浏览器操作
  • 关系图：赋能数据可视化的动态扩展
  • C++11QT复习 （五）