【玩转c++】c++：string类讲解（万字详解）-创新互联

目录
我们提供的服务有：做网站、网站设计、微信公众号开发、网站优化、网站认证、仪征ssl等。为1000多家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的仪征网站制作公司
🍁1. 为什么要学习string类
🍁2. 标准库中的string类
🍁3. string类各种接口
默认成员函数
Iterators迭代器
capacity容量
Element access:元素访问
Modifiers:修改
字符串操作
成员变量
非成员函数
🍁4. 扩展阅读

本期主题：c++string类的介绍
博客主页：小峰同学
分享小编的在Linux中学习到的知识和遇到的问题
小编的能力有限，出现错误希望大家不吝赐
做为程序员不会有人还没女朋友吧？

🍁1. 为什么要学习string类

C语言中的字符串

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

两个 oj 题

ll字符串转整形数字

字符串相加

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

🍁2. 标准库中的string类

字符串是表示字符序列的类
string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)

string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(关于更多的模板信息请参考basic_string)。

注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。还有一些别的编码类型的字符串类，比如支持utf-16的u16string，支持utf-32的u32string。

总结：
1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。比特就业课
3. string在底层实际是：basic_string模板类的别名，typedef basic_stringstring;
这里的是typedef basic_stringstring ,而不是 typedef basic_string string，因为basic_string 是模板名不是类型，basic_string才是类型。
4. 不能操作多字节或者变长字符的序列。
多字节的需要用到 u16string，或者 u32string ，或者 wstring 类型。
5.在使用string类时，必须包含#include头文件以及using namespace std;

🍁3. string类各种接口

由于我们主要用的是utf-8 编码的字符串，所以本文章，主要讲解string类。

默认成员函数

(cinstructor)构造

int main()
{
	//string();
	string s;
	cout<< s<//string(InputIterator first, InputIterator last);
	string::iterator first = s1.begin();//s1 = "zhang"
	string::iterator last  = s1.end();
	string s9(first,last);
	cout<< s9<< endl;//zhang


	return 0;
}

destructor销毁

operator= 赋值重载

int main()
{
	string s1("zhang");
	string s2;
	s2 = s1;
	cout<< s2<< endl;

	string s3;
	s3 = "zhang";
	cout<< s3<< endl;

	string s4;
	s4 = 'z';
	cout<< s4<< endl;


	return 0;
}

三种遍历方式：

1.下标
2.范围for
3.迭代器

int main()
{
	string s1("123456");

	//下标
	for (int i = 0; i< s1.size(); i++)
	{
		s1[i]++;
		//本质生是调用 operator[];
	}
	cout<< s1<< endl;//234567

	//范围for
	for (auto& i : s1)
	{
		i++;
	}
	cout<< s1<< endl;//345678

	//迭代器 
	string::iterator first = s1.begin();
	while (first != s1.end())
	{
		(*first)++;
		first++;
	}
	cout<< s1<< endl;//456789

	return 0;
}

Iterators迭代器

begin迭代器开端，重载了两个分别返回，iterator 和 const_iterator (参数是常量的，返回常量迭代器）
end()迭代器的结束，重载了两个分别返回，iterator 和 const_iterator (参数是常量的，返回常量迭代器）

int main()
{
	string s1("zhang");
	string::iterator first = s1.begin();
	string::iterator last = s1.end();
	while (first != last){
		cout<< (*first);//这里可读可写
		first++;
	}	cout<< endl;

	const string s2("zhang");//s2 是const 类型的
	//string::iterator rfirst = s2.begin();//这个会报错
	//string::iterator rlast = s2.end();//权限提升报错
	string::const_iterator cfirst = s2.begin();
	string::const_iterator clast = s2.end();
	while (cfirst != clast){
		cout<< (*cfirst);//这里只是可读
		cfirst++;
	}	cout<< endl;

	return 0;
}

rbegin迭代器开端，重载了两个分别返回，reverse_iterator 和 const_reverse_iterator (参数是常量的，返回常量迭代器）
rend()迭代器的结束，重载了两个分别返回，reverse_iterator 和 const_reverse_iterator (参数是常量的，返回常量迭代器）

int main()
{
	string s2("123456");

	string::reverse_iterator rfirst = s2.rbegin();
	string::reverse_iterator rlast = s2.rend();
	while (rfirst != rlast){
		cout<< (*rfirst);//这里可读可写
		rfirst++;//注意这里是++ ，不是--
	}//654321
	cout<< endl;

	const string s3(s2);
	string::const_reverse_iterator  crfirst = s3.rbegin();
	string::const_reverse_iterator  crlast = s3.rend();
	while (crfirst != crlast) {
		cout<< (*crfirst);//这里可读不可写
		//(*crfirst)++;不可写
		crfirst++;
	}//654321

	return 0;
}

capacity容量

int main()
{
	string s1("123456");
	//size()有效字符的长度
	cout<< s1.size()<< endl;
	//length()长度
	cout<< s1.length()<< endl;
	//max_size()最长长度（无意义）任何string类型都是一样的：4294967294
	cout<< s1.max_size()<< endl;
	//capacity() //容量空间的大小
	cout<< s1.capacity()<< endl;	
	//clear//清空数据，到底清理空间与否，不知道（VS没有清理空间)
	s1.clear();
	cout<< s1.capacity()<< endl;
	cout<< s1.size()<< endl;
	s1.reserve(200);
	//shrink_to_fit() //减小容量，让字符串减小其容量以适合其大小,可能不是和size相同
	s1.shrink_to_fit();
	cout<< s1.capacity()<< endl;
	cout<< s1.size()<< endl;

	string s("123456");
	string s2(s);
	//reserve()//提前开辟n个空间。
	//提前看开辟空间，减小扩容次数，提高效率。
	s2.reserve(100);//不会改变size
	cout<< s2.capacity()<< endl;
	cout<< s2.size()<< endl;


	string s3(s);
	string s4(s);
	string s5(s);
	//resize() //把string的长度改变到n
	//ncapacity,插入数据顺便扩容,没有给定值默认是'\0'。
	cout<< s.capacity()<< endl;//15
	cout<< s.size()<< endl;//6
	s3.resize(4);
	cout<< s3.size()<< endl;
	cout<< s3.capacity()<< endl;
	cout<< s3<< endl;
	s4.resize(10,'x');
	cout<< s4.size()<< endl;
	cout<< s4.capacity()<< endl;
	cout<< s4<< endl;
	s5.resize(20,'x');
	cout<< s5.size()<< endl;
	cout<< s5.capacity()<< endl;
	cout<< s5<< endl;


	return 0;
}

注意：
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不会改变容量大小。

Element access:元素访问

Modifiers:修改

int main()
{
	string s1 = "zhang";
	string s2 = "xue";
	s1 += s2;
	cout<< s1<< endl;//zhangxue
	const char* pc = "feng";
	s1 += pc;
	cout<< s1<< endl;//zhangxuefeng
	char p = 'z';
	s1 += p;
	cout<< s1<< endl;//zhangxuefengz
	return 0;
}

int main()
{
	string s1 = "zhang";
	string s2 = "xue";
	s1.append(s2);
	cout<< s1<< endl;//zhangxue
	string s3 = "feng";
	s1.append(s3, 0,2);
	cout<< s1<< endl;//zhangxuefe
	char p1[] = "ng";
	s1.append(p1);
	cout<< s1<< endl;//zhangxuefeng
	char p2[] = "gao";
	s1.append(p2,2);
	cout<< s1<< endl;//zhangxuefengga
	s1.append(2, 'z');
	cout<< s1<< endl;//zhangxuefenggazz
	return 0;
}

int main()
{
	string s1;
	s1.push_back('z');
	s1.push_back('h');
	s1.push_back('a');
	s1.push_back('n');
	s1.push_back('g');
	cout<< s1<< endl;//zhang

	return 0;
}

#include#includeusing namespace std;

int main()
{
	string s1("gaowenya");
	string s2 = "zhangxuefeng";
	s1.assign(s2);
	cout<< s1<< endl;//zhangxuefeng

	//s1.clear();
	s1.assign("zhangxuefeng");
	cout<< s1<< endl;//zhangxuefeng


	s1.clear();//这里是否手动清理与否都一样，assign会自己清理。
	s1.assign(s2,5,3);
	cout<< s1<< endl;//xue

	s1.clear();
	s1.assign("zhangxuefeng", 5);
	cout<< s1<< endl;//zhang

	s1.clear();
	s1.assign(5, '5');
	cout<< s1<< endl;//55555

	string::const_iterator first = s2.begin();
	string::const_iterator back = s2.end();
	first++;
	back--;
	s1.assign(first, back);
	cout<< s1<< endl;//hangxuefen

	return 0;
}

#include#includeusing namespace std;


int main()
{
	string s1;
	s1 = "0123456789";
	const char* s2 = "zhangxuefeng";
	string s3 = "gaowenya";

	s1.insert(5, s3);
	cout<< s1<< endl;//01234gaowenya56789

	s1 = "0123456789";
	s1.insert(5, s3,3,3 );
	cout<< s1<< endl;//01234wen56789

	s1 = "0123456789";
	s1.insert(5, s2,5);
	cout<< s1<< endl;//01234zhang56789

	s1 = "0123456789";
	s1.insert(5, 5, 'z');
	cout<< s1<< endl;//01234zzzzz56789



	string s5 = "0123456789";
	//string::const_iterator p = s5.begin();
	string::iterator p = s5.begin();

	s5.insert(p+5, 5, 'z');
	cout<< s5<< endl;//01234zzzzz56789

	s5.insert(p+1, 'z');
	cout<< s5<< endl;//0z1234zzzzz56789


	string s4 = "zhangxuefeng";
	string::iterator first = s4.begin();
	string::iterator last = s4.end();
	
	string s6 = "0123456789";
	string::iterator p2 = s6.begin();
	s6.insert(p2 + 5, first, last);
	cout<< s6<< endl;//01234zhangxuefeng56789


	return 0;
}

#include#includeusing namespace std;

int main()
{
	string s1 = "zhangxuefeng";
	s1.erase(5, 3);
	cout<< s1<< endl;//zhangfeng

	string s2 = "zhangxuefeng";
	s2.erase(5);
	cout<< s2<< endl;//zhang


	string s3 = "zhangxuefeng";
	string::iterator first = s3.begin();
	s3.erase(first + 5);
	cout<< s3<< endl;//zhanguefeng

	string s4 = "zhangxuefeng";
	string::iterator first4 = s4.begin();
	s4.erase(first4 + 5, first4 + 8);
	cout<< s4<< endl;//zhangfeng



	return 0;
}

int main()
{
	string s2 = "zhangxuefeng";
	s2.replace(5, 3, "zhang");//xue 用 zhang  替换掉
	cout<< s2<< endl;

	return 0;
}

int main()
{
	string s1("zhang");
	string s2("gao");
	cout<< "交换前"<< endl;
	cout<< s1<< endl;
	cout<< s2<< endl;
	s1.swap(s2);
	cout<< "交换后"<< endl;
	cout<< s1<< endl;
	cout<< s2<< endl;
	return 0;
}

注意：
1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
3.replace和assign区别：assign是先清理再替换，replace是直接替换不会清理。

字符串操作

#include#include#includeusing namespace std;

int main()
{
	string str("Please split this sentence into tokens");

	char* cstr = new char[str.length() + 1];
	//strcpy(cstr, str.c_str());
	std::strcpy(cstr, str.data());

	// cstr now contains a c-string copy of str

	char* p = strtok(cstr, " ");
	while (p != 0)
	{
		cout<< p<< endl;
		p = strtok(NULL, " ");
	}
	//Please
	//split
	//this
	//sentence
	//into
	//tokens

	delete[] cstr;
	return 0;
}

#include#includeusing namespace std;
int main()
{
	char buffer[20];
	string s1("zhang xue feng");
	size_t len = s1.copy(buffer, 3, 6);//注意3  6  的意义。
	buffer[len] = '\0';
	//注意要手动加上'\0'，copy不会自动加'\0'。
	cout<< buffer<< endl;//xue
	return 0;
}

#include#includeusing namespace std;

int main()
{
	string str("There are two needles in this haystack with needles.");
	string str2("needle");

	// different member versions of find in the same order as above:
	size_t found = str.find(str2);
	if (found != string::npos)
		cout<< "first 'needle' found at: "<< found<< '\n';

	found = str.find("needles are small", found + 1, 6);//这里不给出6就默认屁匹配别的函数重载
	if (found != string::npos)
		cout<< "second 'needle' found at: "<< found<< '\n';

	found = str.find("haystack");
	if (found != string::npos)
		cout<< "'haystack' also found at: "<< found<< '\n';

	found = str.find('.');
	if (found != string::npos)
		cout<< "Period found at: "<< found<< '\n';

	// let's replace the first needle:
	str.replace(str.find(str2), str2.length(), "preposition");//把s2 对象内容换成preposition。
	cout<< str<< '\n';

	return 0;
}

#include#includeusing namespace std;
int main()
{
	string s1("test.cpp.tar");
	size_t len1 = s1.find('.');
	size_t len2 = s1.rfind('.');
	cout<< "find: "<< s1.substr(len1)<< endl;
	cout<< "rfind: "<< s1.substr(len2)<< endl;
	return 0;
}

#include#includeusing namespace std;

int main()
{
	string str("Please, replace the vowels in this sentence by asterisks.");
	size_t found = str.find_first_of("aeiou");
	int i = 5;
	while (i--)
	{
		str[found] = '*';
		found = str.find_first_of("aeiou", found + 1);
	}
	cout<< str<< '\n';
	//Pl**s*, r*pl*c* the vowels in this sentence by asterisks.
	return 0;
}

#include#includeusing namespace std;
int main()
{
	string str("Please, replace the vowels in this sentence by asterisks.");
	size_t found = str.find_last_of("aeiou");
	int i = 5;
	while (i--)
	{
		str[found] = '*';
		found = str.find_last_of("aeiou", found + 1);
	}
	cout<< str<< '\n';
	//Please, replace the vowels in this sent*nc* by *st*r*sks.

	return 0;
}

成员变量

非成员函数

#include#includeusing namespace std;
int main()
{
	string s1("zhang");
	const char* s2 = "xue";
	string s3("feng");
	string s4 = s1 + s2 + s3;
	cout<< s4<< endl;
	//zhangxuefeng
	return 0;
}

#include#includeusing namespace std;
int main()
{
	string s1("zhang");
	string s2("gao");
	s1.swap(s2);//这个是内置函数
	swap(s1, s2);//这个是非成员函数，和全局内置的swap构成函数重载
	return 0;
}

int main()
{
	string str1;
	getline(cin, str1);
	//这样写遇见空格不会结束读取，只有遇到回车才会结束读取。
	cout<< str1<< endl;

	string str2;
	getline(cin, str2,'.');//只有遇到  '.'  才会结束读取。
    //此时'\n'只是一个普通的字符串，用于刷新缓冲区。
	cout<< str2<< endl;

	string str3;
	cin >>str3;//遇见空格和回车会结束读取。
	cout<< str3<< endl;

	return 0;
}

🍁4. 扩展阅读

vs和Linuxg++下string类的大小。

注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。
vs下string的结构 string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，
联合体用来定义string中字符串的存储空间：
当字符串长度小于16时，使用内部固定的字符数组来存放
当字符串长度大于等于16时，从堆上开辟空间
这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量
最后：还有一个指针做一些其他事情。故总共占16+4+4+4=28个字节。