• C++ 学习（17）STL - vector容器、string容器

    1、STL

    STL（Standard Template Library）标准模板库，是C++为建立 数据结构与算法的一套标准。STL从广义上分为：容器（container）、算法（algorithm）、迭代器（iterator），容器和算法之间通过迭代器进行无缝连接。STL几乎所有的代码都采用了类模板或者函数模板。

    1.1、STL六大组件

    容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

    1. 容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据
    2. 算法：各种常用的算法，如sort、find、copy、for_each等
    3. 迭代器：扮演了容器与算法之间的粘合剂
    4. 仿函数：行为类似函数，可作为算法的某种策略
    5. 适配器：一种用来修饰容器或者仿函数或迭代器接囗的东西
    6. 空间配置器：负责空间的配置与管理

    （1）容器（置物之所也）

    STL容器就是将运用最广泛的一些数据结构实现出来，常用的数据结构包含：数组、链表、树、栈、队列、集合、映射表等；这些容器分为序列式容器与关联式容器两种：

    • 序列式容器：强调值的排序，序列式容器中的每个元素均有固定的位置
    • 关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系

    （2）算法（问题之解法也）

    有限的步骤解决逻辑或数学上的问题，这一门学科叫做算法。算法分为质变算法与非质变算法：

    • 质变算法：是指运算过程中会更改区间内的元素的内容，如拷贝、替换、删除等
    • 非质变算法：是指运算过程中不会更改区间内的元素内容，如查找、计数、遍历、寻找极值等

    （3）迭代器（容器和算法之间的粘合剂）

    提供一种方法，使用之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。每个容器都有自己专属的迭代器。迭代器使用非常类似于指针，初学阶段也可以先将迭代器理解为指针。迭代器种类划分五种：

    • 输入迭代器： 对数据只读访问，支持++、==、!=
    • 输出迭代器：对数据只写访问，支持++
    • 前向迭代器：读写操作，并能向前推进迭代器，支持++、==、!=
    • 双向迭代器：读写操作，并能向前和向后操作，支持++、--
    • 随机访问迭代器：读写操作，可以心跳跃的方式访问任意数据，功能最强的迭代器，支持++、--、[n]、-n、<、<=、>、>=

    2、vector容器

    STL中最常用的容器为vector，vector数据结构与数组非常相似，也称为单端数组。

    vector与普通数组的区别在于数组是静态空间，而vector可以动态扩展。所谓动态扩展，并不是在原空间之后维埃拉新空间，而是找更大的内存空间，然后将原数据拷贝至新空间中，释放原空间。

    vector容器的迭代器是支持随机访问的迭代器。

    容器：vector

    算法：for_each

    迭代器：vector::iterator

    2.1、vector构造函数

    函数原型：

    • vector v;                        //采用模板实现类，默认构造函数
    • vector(v.begin(), v.end());    //将v[begin(), end()]区间中的元素拷贝给其本身
    • vecotr(n, elem);                  //构造函数将n个elem拷贝给本身
    • vector(const vector& vec); //拷贝构造函数
    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. void print(vector<int>& v)
    7. {
    8. 	for (int i = 0; i < v.size(); i++)
    9. 	{
    10. 		cout << v[i] << "\t";
    11. 	}
    12. 	cout <<  endl;
    13. }
    14.  
    15. int main()
    16. {
    17. 	// STL - vector - 构造函数
    18. 	/*函数原型：
    19. 		1、vector v;                        //采用模板实现类，默认构造函数
    20. 		2、vector(v.begin(), v.end());    //将v[begin(), end()]区间中的元素拷贝给其本身
    21. 		3、vecotr(n, elem);                  //构造函数将n个elem拷贝给本身
    22. 		4、vector(const vector& vec); //拷贝构造函数
    23. 	
    24. 	*/
    25.  
    26. 	//1、vector v; 
    27. 	vector<int> v1;
    28.  
    29. 	//赋值
    30. 	for (int i = 0; i < 5; i++)
    31. 	{
    32. 		v1.push_back(i + 1);
    33. 	}
    34.  
    35. 	//显示
    36. 	print(v1);
    37.  
    38. 	//2、vector(v.begin(), v.end());
    39. 	vector<int> v2(v1.begin(), v1.end());
    40. 	print(v2);
    41.  
    42. 	//3、vecotr(n, elem);    
    43. 	vector<int> v3(3,8);
    44. 	print(v3);
    45.  
    46. 	//4、vector(const vector& vec);
    47. 	vector<int> v4(v1);
    48. 	print(v4);
    49.  
    50. 	system("pause");
    51.  
    52. 	return 0;
    53. }

    输出结果

    1       2       3       4       5
    1       2       3       4       5
    8       8       8
    1       2       3       4       5

    2.2、vector赋值操作

    函数原型：

    • vector& operator=(const vector &vec);  //重载=运算符
    • assign(beg, end);      //将[beg, end)区间中的数据拷贝赋值给本身
    • assign(n, elem);        //将n个elem拷贝赋值给本身
    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. void print(vector<int>& v)
    7. {
    8. 	for (int i = 0; i < v.size(); i++)
    9. 	{
    10. 		cout << v[i] << "\t";
    11. 	}
    12. 	cout << endl;
    13. }
    14.  
    15. int main()
    16. {
    17. 	// STL - vector - 赋值操作
    18. 	/*函数原型：
    19. 		1、vector& operator=(const vector &vec);  //重载=运算符
    20. 		2、assign(beg, end);      //将[beg, end)区间中的数据拷贝赋值给本身
    21. 		3、assign(n, elem);        //将n个elem拷贝赋值给本身
    22. 	*/
    23.  
    24. 	vector<int> v1;
    25. 	for (int i = 0; i < 5; i++)
    26. 	{
    27. 		v1.push_back(i + 1);
    28. 	}
    29. 	//1、vector& operator=(const vector &vec);
    30. 	vector<int> v2;
    31. 	v2 = v1;
    32. 	print(v2);
    33.  
    34. 	//2、assign(beg, end); 
    35. 	vector<int> v3(v1.begin(), v1.end());
    36. 	print(v3);
    37.  
    38. 	//3、assign(n, elem); 
    39. 	vector<int> v4;
    40. 	v4.assign(3, 8);
    41. 	print(v4);
    42.  
    43. 	system("pause");
    44.  
    45. 	return 0;
    46. }

    输出结果

    1       2       3       4       5
    1       2       3       4       5
    8       8       8

    2.3、vector容量和大小

    函数原型

    • empty();                        //判断容器是否为空
    • capacity();                    //容器容量
    • size();                          //返回容器中元素个数
    • resize(int num);          //重新指定窗口的长度为num，若容器变长，则以默认值填充新位置，如果变短，则末尾超出容器长度的元素被删除。
    • resize(int num, elem); //重新指定容器长度的num，基容器变长，则以elem值填充新位置；如果变短，则末尾超出容器长度的元素被删除。
    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. void print(vector<int>& v)
    7. {
    8. 	for (int i = 0; i < v.size(); i++)
    9. 	{
    10. 		cout << v[i] << "\t";
    11. 	}
    12. 	cout << endl;
    13. }
    14.  
    15. int main()
    16. {
    17. 	// STL - vector - 赋值操作
    18. 	/*函数原型：
    19. 		1、empty();               //判断容器是否为空
    20. 		2、capacity();            //容器容量
    21. 		3、size();                //返回容器中元素个数
    22. 		4、resize(int num);       //重新指定窗口的长度为num，若容器变长，则以默认值填充新位置，如果变短，则末尾超出容器长度的元素被删除。
    23. 		5、resize(int num, elem); //重新指定容器长度的num，基容器变长，则以elem值填充新位置；如果变短，则末尾超出容器长度的元素被删除。
    24. 	*/
    25.  
    26. 	//1、empty();  
    27. 	vector<int> v1;
    28. 	cout << "1、容器是否为空：" << (v1.empty() ? "容器为空" : "容器不为空") << endl;
    29.  
    30. 	for (int i = 0; i < 5; i++)
    31. 	{
    32. 		v1.push_back(i + 1);
    33. 	}
    34.  
    35. 	cout << "1、容器是否为空：" << (v1.empty() ? "容器为空" : "容器不为空") << endl;
    36. 	cout << "1、容器元素：" << endl;
    37. 	print(v1);
    38.  
    39. 	//2、capacity();
    40. 	cout << "2、容器容量：" << v1.capacity() << endl;
    41.  
    42. 	//3、size();  
    43. 	cout << "3、容器中元素个数：" << v1.size() << endl;
    44.  
    45. 	//4、resize(int num);
    46. 	v1.resize(7);
    47. 	cout << "4、容器长度变长后元素：" << endl;
    48. 	print(v1);
    49. 	v1.resize(4);
    50. 	cout << "4、容器长度变短后元素：" << endl;
    51. 	print(v1);
    52.  
    53. 	//5、resize(int num, elem);
    54. 	v1.resize(7, 8);
    55. 	cout << "5、容器长度变长后元素：" << endl;
    56. 	print(v1);
    57. 	v1.resize(5);
    58. 	cout << "5、容器长度变短后元素：" << endl;
    59. 	print(v1);
    60.  
    61. 	system("pause");
    62.  
    63. 	return 0;
    64. }

    输出结果

    1、容器是否为空：容器为空
    1、容器是否为空：容器不为空
    1、容器元素：
    1       2       3       4       5
    2、容器容量：6
    3、容器中元素个数：5
    4、容器长度变长后元素：
    1       2       3       4       5       0       0
    4、容器长度变短后元素：
    1       2       3       4
    5、容器长度变长后元素：
    1       2       3       4       8       8       8
    5、容器长度变短后元素：
    1       2       3       4       8

    2.4、vector插入与删除

    函数原型

    插入元素

    • push_back(ele);                         //尾部插入元素
    • insert(const_iterator pos, ele);  //迭代器指向位置pos插入元素ele
    • insert(const_iterator pos, int count, ele);  //迭代器指向位置pos插入count个元素ele

    删除元素

    • pop_back();                           //删除最后一个元素
    • erase(const_iterator pos);    //删除迭代器指向的元素
    • earse(const_iterator start, const_iterator end);  //删除迭代器从start到end之间的元素
    • clear();                                 //删除容器中所有元素 
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. void print(vector<int>& v)
    6. {
    7. 	for (int i = 0; i < v.size(); i++)
    8. 	{
    9. 		cout << v[i] << "\t";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. int main()
    15. {
    16. 	// STL - vector - 插入和删除
    17. 	/*函数原型
    18. 	插入元素：
    19. 		1、push_back(ele);                //尾部插入元素
    20. 		2、insert(const_iterator pos, ele);  //迭代器指向位置pos插入元素ele
    21. 		3、insert(const_iterator pos, int count, ele);  //迭代器指向位置pos插入count个元素ele
    23. 	删除元素：
    24. 		4、pop_back();                      //删除最后一个元素
    25. 		5、erase(const_iterator pos);    //删除迭代器指向的元素
    26. 		6、earse(const_iterator start, const_iterator end);  //删除迭代器从start到end之间的元素
    27. 		7、clear();         //删除容器中所有元素
    28. 	*/
    29. 	vector<int> v1;
    30. 	//1、2、3 插入元素; 
    31. 	v1.push_back(20);
    32. 	cout << "1、插入元素后：";
    33. 	print(v1);
    34.  
    35. 	v1.insert(v1.begin(), 32);
    36. 	cout << "2、插入元素后：";
    37. 	print(v1);
    38.  
    39. 	v1.insert(v1.begin(), 3,50);
    40. 	cout << "3、插入元素后：";
    41. 	print(v1);
    42.  
    43. 	//4、5、6、7 删除元素;   
    44. 	v1.pop_back();
    45. 	cout << "4、删除元素后：";
    46. 	print(v1);
    47.  
    48. 	v1.erase(v1.begin());
    49. 	cout << "5、删除元素后：";
    50. 	print(v1);
    51.  
    52. 	v1.erase(v1.begin(), v1.end());
    53. 	cout << "6、删除元素后：";
    54. 	print(v1);
    55.  
    56. 	v1.insert(v1.begin(), 3, 50);
    57. 	cout << "3、插入元素后：";
    58. 	print(v1);
    59.  
    60. 	v1.clear();
    61. 	cout << "7、删除元素后：";
    62. 	print(v1);
    63.  
    64. 	system("pause");
    65.  
    66. 	return 0;
    67. }

    输出结果

    1、插入元素后：20
    2、插入元素后：32       20
    3、插入元素后：50       50      50      32      20
    4、删除元素后：50       50      50      32
    5、删除元素后：50       50      32
    6、删除元素后：
    3、插入元素后：50       50      50
    7、删除元素后：

    2.5、vector数据读取

    函数原型

    • at(int idx);   //返回索引idx所指向的数据
    • operator[];  //返回索引idx所指向的数据
    • front();       //返回容器中第一个数据元素
    • back();      //返回容器中最后一个数据元素
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. void print(vector<int>& v)
    6. {
    7. 	for (int i = 0; i < v.size(); i++)
    8. 	{
    9. 		cout << v[i] << "\t";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. int main()
    15. {
    16. 	// STL - vector - 数据读取
    17. 	/*函数原型
    18. 		1、at(int idx); //返回索引idx所指向的数据
    19. 		2、operator[];  //返回索引idx所指向的数据
    20. 		3、front();     //返回容器中第一个数据元素
    21. 		4、back();      //返回容器中最后一个数据元素
    22. 	*/
    23. 	vector<int> v1;
    24. 	for (int i = 0; i < 5; i++)
    25. 	{
    26. 		v1.push_back(i * 5);
    27. 	}
    28. 	cout << "容器中的元素：";
    29. 	print(v1);
    30.  
    31. 	//1、at(int idx);
    32. 	cout << "1、读取第1个元素：" << v1.at(0) << endl;
    33.  
    34. 	//2、operator[];
    35. 	cout << "2、读取第2个元素：" << v1[1] << endl;
    36.  
    37. 	//3、front();
    38. 	cout << "3、读取容器中第1个元素：" << v1.front() << endl;
    39.  
    40. 	//4、back(); 
    41. 	cout << "4、读取容器中最后1个元素：" << v1.back() << endl;
    42.  
    43. 	system("pause");
    44.  
    45. 	return 0;
    46. }

    输出结果

    容器中的元素：0 5       10      15      20
    1、读取第1个元素：0
    2、读取第2个元素：5
    3、读取容器中第1个元素：0
    4、读取容器中最后1个元素：20

    2.6、vector互换容器

    可以巧妙使用互换容器收缩内存空间，使用vector匿名对象与当前vector互换容器，匿名对象特点是当前执行完，编译器立即回收内存空间，因此互换后之间的空间被释放了。

    函数原型

    • swap(vec);  //将vec与本身的元素互换
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. void print(vector<int>& v)
    6. {
    7. 	for (int i = 0; i < v.size(); i++)
    8. 	{
    9. 		cout << v[i] << "\t";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. int main()
    15. {
    16. 	// STL - vector - 互换容器
    17. 	/*函数原型
    18. 		swap(vec);  //将vec与本身的元素互换
    19. 	*/
    20.  
    21. 	vector<int> v1;
    22. 	for (int i = 0; i < 5; i++)
    23. 	{
    24. 		v1.push_back(i * 5);
    25. 	}
    26. 	cout << "交换前，v1 容器中的元素：";
    27. 	print(v1);
    28. 	cout << "交换前，v1 容器容量：" << v1.capacity() << ", 容器大小：" << v1.size() << endl;
    29.  
    30. 	vector<int> v2;
    31. 	for (int i = 0; i < 7; i++)
    32. 	{
    33. 		v2.push_back(i + 5);
    34. 	}
    35. 	cout << "交换前，v2 容器中的元素：";
    36. 	print(v2);
    37. 	cout << "交换前，v2 容器容量：" << v2.capacity() << endl;
    38. 	cout << "交换前，v2 容器大小：" << v2.size() << endl;
    39.  
    40. 	v1.swap(v2);
    41.  
    42. 	cout << "交换后，v1 容器中的元素：";
    43. 	print(v1);
    44. 	cout << "交换后，v1 容器容量：" << v1.capacity() << ", 容器大小：" << v1.size() << endl;
    45.  
    46. 	cout << "交换后，v2 容器中的元素：";
    47. 	print(v2);
    48. 	cout << "交换后，v2 容器容量：" << v2.capacity() << ", 容器大小：" << v2.size() << endl;
    49.  
    50. 	//可以巧妙使用互换容器收缩内存空间，使用vector匿名对象与当前vector互换容器，
    51. 	//匿名对象特点是当前执行完，编译器立即回收内存空间，因此互换后之间的空间被释放了。
    52. 	vector<int> v3;
    53. 	for (int i = 0; i < 5000; i++)
    54. 	{
    55. 		v3.push_back(i);
    56. 	}
    57. 	cout << "交换前，v3 容器容量：" << v3.capacity() << ", 容器大小：" << v3.size() << endl;
    58.  
    59. 	v3.resize(5);
    60. 	cout << "重置resize容器大小" << endl;
    61. 	cout << "重置后，v3 容器容量：" << v3.capacity() << ", 容器大小：" << v3.size() << endl;
    62.  
    63. 	//vector(v3)为使用拷贝构造函数生成一个匿名对象，使用匿名对象调用swap函数
    64. 	vector<int>(v3).swap(v3);
    65. 	cout << "与匿名对象交换后，v3 容器容量：" << v3.capacity() << ", 容器大小：" << v3.size() << endl;
    66.  
    67. 	system("pause");
    68.  
    69. 	return 0;
    70. }

    输出结果

    交换前，v1 容器中的元素：0      5       10      15      20
    交换前，v1 容器容量：6, 容器大小：5
    交换前，v2 容器中的元素：5      6       7       8       9       10      11
    交换前，v2 容器容量：9
    交换前，v2 容器大小：7
    交换后，v1 容器中的元素：5      6       7       8       9       10      11
    交换后，v1 容器容量：9, 容器大小：7
    交换后，v2 容器中的元素：0      5       10      15      20
    交换后，v2 容器容量：6, 容器大小：5
    交换前，v3 容器容量：5395, 容器大小：5000
    重置resize容器大小
    重置后，v3 容器容量：5395, 容器大小：5
    与匿名对象交换后，v3 容器容量：5, 容器大小：5

    2.7、vector预留空间

    减少vector在动态扩展容量时的扩展次数，函数原型：

    • reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - vector - 预留空间
    8. 	/*函数原型
    9. 		reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问
    10. 	*/
    11.  
    12. 	vector<int> v1;
    13. 	int* p = NULL;
    14. 	int count = 0;
    15. 	//计算初始化5000个元素，会分配多少次内存空间
    16. 	for (int i = 0; i < 5000; i++)
    17. 	{
    18. 		v1.push_back(i);
    19. 		if (p != &v1[0])
    20. 		{
    21. 			p = &v1[0];
    22. 			count++;
    23. 		}
    24. 	}
    25. 	cout << "分配内存空间次数：" << count << endl;
    26. 	
    27. 	//预留空间
    28. 	vector<int> v2;
    29. 	v2.reserve(5000);
    30. 	p = NULL;
    31. 	count = 0;
    32.  
    33. 	for (int i = 0; i < 5000; i++)
    34. 	{
    35. 		v2.push_back(i);
    36. 		if (p != &v2[0])
    37. 		{
    38. 			p = &v2[0];
    39. 			count++;
    40. 		}
    41. 	}
    42. 	cout << "预留空间后，分配内存空间次数：" << count << endl;
    43.  
    44. 	system("pause");
    45.  
    46. 	return 0;
    47. }

    输出结果

    分配内存空间次数：22
    预留空间后，分配内存空间次数：1

    2.8、vector存放内置数据类型

    1. #include 
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. void print(int val)
    7. {
    8. 	cout << val << "\t";
    9. }
    10.  
    11. int main()
    12. {
    13. 	// STL - vector - 存放内置数据类型
    14. 	//创建vetor容器对象，并且通过模板参数指定容器中存放的数据类型
    15. 	vector<int> v;
    16. 	//向容器中存放数据
    17. 	v.push_back(21);
    18. 	v.push_back(15);
    19. 	v.push_back(87);
    20.  
    21. 	//v.begin()返回迭代器，这个迭代器指向容器中第一个数据
    22. 	//vector::iterator 拿到vector这个容器的迭代器类型
    23. 	vector<int>::iterator itBegin = v.begin();
    24. 	//v.end()返回迭代器，这个迭代器指向容器中最后一个元素的下一个位置
    25. 	vector<int>::iterator itEnd = v.end();
    26.  
    27. 	cout << "--- 遍历方式一 while ---" << endl;
    28.  
    29. 	//遍历方式一
    30. 	while (itBegin != itEnd)
    31. 	{
    32. 		cout << *itBegin << "\t";
    33. 		itBegin++;
    34. 	}
    35. 	cout << endl;
    36.  
    37. 	cout << endl << "--- 遍历方式二 for ---" << endl;
    38.  
    39. 	//遍历方式二
    40. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    41. 	{
    42. 		cout << *it << "\t";
    43. 	}
    44. 	cout << endl;
    45.  
    46. 	cout << endl << "--- 遍历方式二 for_each ---" << endl;
    47.  
    48. 	//遍历方式三 - STL提供的遍历算法
    49. 	for_each(v.begin(), v.end(), print);
    50.  
    51. 	system("pause");
    52.  
    53. 	return 0;
    54. }

    输出结果

    --- 遍历方式一 while ---
    21      15      87

    --- 遍历方式二 for ---
    21      15      87

    --- 遍历方式二 for_each ---
    21      15      87

    2.9、vector存放自定义数据类型

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //自定义类型
    6. class Person
    7. {
    8. public:
    9. 	string name;
    10. 	int age;
    11.  
    12. 	Person(string _name, int _age): name(_name), age(_age) {}
    13. };
    14.  
    15. int main()
    16. {
    17. 	// STL - vector - 存放自定义数据类型
    18. 	Person p1("Tracy", 20);
    19. 	Person p2("Timo", 27);
    20. 	Person p3("Alice", 15);
    21.  
    22. 	cout << "--- vector存放对象 ---" << endl;
    23.  
    24. 	vector v1;
    25.  
    26. 	v1.push_back(p1);
    27. 	v1.push_back(p2);
    28. 	v1.push_back(p3);
    29.  
    30. 	//遍历
    31. 	for (vector::iterator it = v1.begin(); it < v1.end(); it++)
    32. 	{
    33. 		cout << "name = " << it->name << ", age = " << (*it).age << endl;
    34. 	}
    35.  
    36. 	cout << endl << "--- vector存放对象指针 ---" << endl;
    37.  
    38. 	vector v2;
    39.  
    40. 	v2.push_back(&p1);
    41. 	v2.push_back(&p2);
    42. 	v2.push_back(&p3);
    43.  
    44. 	//遍历 
    45. 	for (vector::iterator it = v2.begin(); it < v2.end(); it++)
    46. 	{
    47. 		cout << "name = " << (*it)->name << ", age = " << (*it)->age << endl;
    48. 	}
    49.  
    50. 	system("pause");
    51.  
    52. 	return 0;
    53. }

    输出结果

    --- vector存放对象 ---
    name = Tracy, age = 20
    name = Timo, age = 27
    name = Alice, age = 15

    --- vector存放对象指针 ---
    name = Tracy, age = 20
    name = Timo, age = 27
    name = Alice, age = 15

    2.10、 容器嵌套容器

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - vector - 容器嵌套容器
    8. 	vectorint>> v;
    9.  
    10. 	vector<int> v1;
    11. 	vector<int> v2;
    12. 	vector<int> v3;
    13.  
    14. 	for (int i = 0; i < 3; i++)
    15. 	{
    16. 		v1.push_back(i + 1);
    17. 		v2.push_back(i + 5);
    18. 		v3.push_back(i + 10);
    19. 	}
    20.  
    21. 	v.push_back(v1);
    22. 	v.push_back(v2);
    23. 	v.push_back(v3);
    24.  
    25. 	//遍历
    26. 	for (vectorint>>::iterator it = v.begin(); it < v.end(); it++)
    27. 	{
    28. 		for (vector<int>::iterator vit = (*it).begin(); vit < (*it).end(); vit++)
    29. 		{
    30. 			cout << *vit << "\t";
    31. 		}
    32. 		cout << endl;
    33. 	}
    34.  
    35. 	system("pause");
    36.  
    37. 	return 0;
    38. }

    输出结果

    1       2       3
    5       6       7
    10      11      12

    3、String容器 

    string是C++风格的字符串，本质上是一个类。

    string和char*区别：

    • char*是一个指针
    • string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器

    string特点：

    • string类内部封装了很多成员方法，如find、copy、delete、replace、insert等。
    • string管理char*所分配的内存，不用担心复制越界和取值越界等问题，由类内部负责处理 

    3.1、string构造函数

    string构造函数原型： 

    • string();                              //创建一个空的字符 串，如 string str;
    • string(const char* s);         //使用字符串s初始化
    • string(const string& str);   //使用一个string对象初始化另一个string对象
    • string(int n, char c);          //使用n个字符c初始化
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - string - 构造函数
    8. 	/*构造原型：
    9. 		1、string();                    //创建一个空的字符 串，如 string str;
    10. 		2、string(const char* s);       //使用字符串s初始化
    11. 		3、string(const string& str);   //使用一个string对象初始化另一个string对象
    12. 		4、string(int n, char c);       //使用n个字符c初始化
    13. 	*/
    14. 	//1、string();             
    15. 	string s1;
    16. 	cout << "s1 = " << s1 << endl;
    17.  
    18. 	//2、string(const char* s);   
    19. 	const char* c = "I am Tracy";
    20. 	string s2(c);
    21. 	cout << "s2 = " << s2 << endl;
    22.  
    23. 	//3、string(const string& str); 
    24. 	string s3(s2);
    25. 	cout << "s3 = " << s3 << endl;
    26.  
    27. 	//4、string(int n, char c); 
    28. 	string s4(5, 'k');
    29. 	cout << "s4 = " << s4 << endl;
    30.  
    31. 	system("pause");
    32.  
    33. 	return 0;
    34. }

    输出结果

    s1 =
    s2 = I am Tracy
    s3 = I am Tracy
    s4 = kkkkk 

    3.2、string赋值操作

    赋值函数原型：

    • string& operator=(const char* s);        //char*类型字符串赋值给当前字符串
    • string& operator=(const string& s);     //把字符串s赋值给当前字符串
    • string& operator=(char c);                  //字符赋值给当前字符串
    • string& assign(const char* s);            //把字符串s赋值给当前字符串
    • string& assign(const char *s, int n);   //把字符串s的前n个字符赋值给当前字符串
    • string& assign(const string& s);        //把字符串s赋值给当前字符串
    • string& assign(int n, char c);             //用n个字符c赋值给当前字符串
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - string - 赋值操作
    8. 	/*赋值函数原型：
    9. 		1、string& operator=(const char* s);       //char*类型字符串赋值给当前字符串
    10. 		2、string& operator=(const string& s);     //把字符串s赋值给当前字符串
    11. 		3、string& operator=(char c);              //字符赋值给当前字符串
    12. 		4、string& assign(const char* s);          //把字符串s赋值给当前字符串
    13. 		5、string& assign(const char *s, int n);   //把字符串s的前n个字符赋值给当前字符串
    14. 		6、string& assign(const string& s);        //把字符串s赋值给当前字符串
    15. 		7、string& assign(int n, char c);          //用n个字符c赋值给当前字符串赋值操作
    16. 	*/
    17.  
    18. 	//1、string& operator=(const char* s);
    19. 	const char* s = "Hello, I am Tray.";
    20. 	string s1 = s;
    21. 	cout << "s1 = " << s1 << endl;
    22.  
    23. 	//2、string& operator=(const string& s);
    24. 	string s2 = s1;
    25. 	cout << "s2 = " << s2 << endl;
    26.  
    27. 	//3、string& operator=(char c); 
    28. 	string s3 = "w";
    29. 	cout << "s3 = " << s3 << endl;
    30.  
    31. 	//4、string& assign(const char* s);
    32. 	string s4;
    33. 	s4.assign(s);
    34. 	cout << "s4 = " << s4 << endl;
    35.  
    36. 	//5、string& assign(const char *s, int n);
    37. 	string s5;
    38. 	s5.assign(s, 5);
    39. 	cout << "s5 = " << s5 << endl;
    40.  
    41. 	//6、string& assign(const string& s);
    42. 	string s6;
    43. 	s6.assign(s5);
    44. 	cout << "s6 = " << s6 << endl;
    45.  
    46. 	//7、string& assign(int n, char c); 
    47. 	string s7;
    48. 	s7.assign(5, 'k');
    49. 	cout << "s7 = " << s7 << endl;
    50.  
    51. 	system("pause");
    52.  
    53. 	return 0;
    54. }

    输出结果

    s1 = Hello, I am Tray.
    s2 = Hello, I am Tray.
    s3 = w
    s4 = Hello, I am Tray.
    s5 = Hello
    s6 = Hello
    s7 = kkkkk       

    3.3、string字符串拼接 

    实现字符串在结尾处拼接，字符串拼接函数原型：

    • string& operator+=(const char* str);       //重载+=操作符
    • string& operator+=(const char c);          //重载+=操作符
    • string& operator+=(const string& str);   //重载+=操作符
    • string& append(const char *s);             //把字符串s连接到当前字符串结尾
    • string& append(const char *s, int n);    //把字符串s的前n个字符连接到当前字符串结尾
    • string& append(const string &s);         //同operator+=(const string& str);
    • string& append(const string& s, int pos, int n); //字符串s中从pos开始的n个字符连接到当前字符串结尾
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - string - 字符串拼接
    8. 	/*字符串拼接函数原型：
    9. 		1、string& operator+=(const char* str);     //重载+=操作符
    10. 		2、string& operator+=(const char c);        //重载+=操作符
    11. 		3、string& operator+=(const string& str);   //重载+=操作符
    12. 		4、string& append(const char *s);           //把字符串s连接到当前字符串结尾
    13. 		5、string& append(const char *s, int n);    //把字符串s的前n个字符连接到当前字符串结尾
    14. 		6、string& append(const string &s);         //同operator+=(const string& str);
    15. 		7、string& append(const string& s, int pos, int n); //字符串s中从pos开始的n个字符连接到当前字符串结尾
    16. 	*/
    17. 	const char* c = "I am busy.";
    18. 	//1、string& operator+=(const char* str);
    19. 	string s1 = "I";
    20. 	s1 += " am Tracy.";
    21. 	cout << "s1 = " << s1 << endl;
    22.  
    23. 	//2、string& operator+=(const char c); 
    24. 	s1 += c;
    25. 	cout << "s1 = " << s1 << endl;
    26.  
    27. 	//3、string& operator+=(const string& str);
    28. 	string s2 = "I am working.";
    29. 	s1 += s2;
    30. 	cout << "s1 = " << s1 << endl;
    31.  
    32. 	//4、string& append(const char *s);   
    33. 	s2.append(c);
    34. 	cout << "s2 = " << s2 << endl;
    35.  
    36. 	//5、string& append(const char *s, int n);    
    37. 	s2.append("I can finish my work.", 5);
    38. 	cout << "s2 = " << s2 << endl;
    39.  
    40. 	//6、string& append(const string &s);  
    41. 	string s3 = "Hello,";
    42. 	s3.append(s2);
    43. 	cout << "s3 = " << s3 << endl;
    44.  
    45. 	//7、string& append(const string& s, int pos, int n);
    46. 	s1.append(s3, 11,4);
    47. 	cout << "s1 = " << s1 << endl;
    48.  
    49. 	system("pause");
    50.  
    51. 	return 0;
    52. }

    输出结果

    s1 = I am Tracy.
    s1 = I am Tracy.I am busy.
    s1 = I am Tracy.I am busy.I am working.
    s2 = I am working.I am busy.
    s2 = I am working.I am busy.I can
    s3 = Hello,I am working.I am busy.I can
    s1 = I am Tracy.I am busy.I am working.work

    3.4、string查找和替换

    查找指定字符串是否存在，替换为在指定位置替换字符串，函数原型如下：

    查找（未找到返回-1）：

    • int find(const string& str, int pos = 0) const;        //查找str第一次出现的位置，从pos开始查找 
    • int find(const char* s, int pos = 0) const;            //查找s第一次出现的位置，从pos开始查找
    • int find(const char* s int pos, int n) const;          //从pos位置查找 s的前n个字符第一次出现的位置
    • int find(const char c, int pos = 0) const;             //查找字符c第一次出现的位置
    • int rfind(const string& str, int pos = npos) const; //查找str最后一次出现的位置，从pos开始查找
    • int rfind(const char* s, int pos = npos) const;   //查找s最后一次出现的位置，从pos开始查找
    • int rfind(const char* s, int pos, int n) const;     //从pos查找 s的前n个字符最后一次出现的位置
    • int rfind(const char c, int pos = 0) const;         //查找字符c最后一次出现的位置

    替换：

    • string& replace(int pos, int n, const string& str);  //替换从pos开始n个字符为字符串str
    • string& replace(int pos, int n, const char* s);      //替换从pos开始的n个字符为字符串s
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - string - 查找和替换
    8. 	/*函数原型：
    9. 		查找：
    10. 		1、int find(const string& str, int pos = 0) const;     //查找str第一次出现的位置，从pos开始查找 
    11. 		2、int find(const char* s, int pos = 0) const;         //查找s第一次出现的位置，从pos开始查找
    12. 		3、int find(const char* s int pos, int n) const;       //从pos位置查找 s的前n个字符第一次出现的位置
    13. 		4、int find(const char c, int pos = 0) const;          //查找字符c第一次出现的位置
    14. 		5、int rfind(const string& str, int pos = npos) const; //查找str最后一次出现的位置，从pos开始查找
    15. 		6、int rfind(const char* s, int pos = npos) const;     //查找s最后一次出现的位置，从pos开始查找
    16. 		7、int rfind(const char* s, int pos, int n) const;     //从pos查找 s的前n个字符最后一次出现的位置
    17. 		8、int rfind(const char c, int pos = 0) const;         //查找字符c最后一次出现的位置
    19. 		替换
    20. 		9、string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
    21. 		10、string& replace(int pos, int n, const char* s);    //替换从pos开始的n个字符为字符串s
    22. 	*/
    23.  
    24. 	string s = "I am happy,I am working now with happiness.";
    25. 	string sf = "ha";
    26. 	const char* sc = "am";
    27. 	//1、int find(const string & str, int pos = 0) const;	
    28. 	cout << "1、 pos = " << s.find(sf) << endl;
    29. 	cout << "1、 pos = " << s.find(sf, 4) << endl;
    30.  
    31. 	int pos = s.find("win");
    32. 	cout << "1、未找到时， pos = " << pos << endl;
    33.  
    34. 	//2、int find(const char* s, int pos = 0) const;  
    35. 	cout << "2、 pos = " << s.find(sc) << endl;
    36. 	cout << "2、 pos = " << s.find(sc, 1) << endl;
    37. 	
    38. 	//3、int find(const char* s int pos, int n) const; 
    39. 	cout << "3、 pos = " << s.find(sc, 10, 2) << endl;
    40. 	
    41. 	//4、int find(const char c, int pos = 0) const; 
    42. 	cout << "4、 pos = " << s.find('a') << endl;
    43. 	cout << "4、 pos = " << s.find('a', 10) << endl;
    44. 	
    45. 	//5、int rfind(const string & str, int pos = npos) const; 
    46. 	cout << "5、 pos = " << s.rfind(sf) << endl;
    47. 	cout << "5、 pos = " << s.rfind(sf, 15) << endl;
    48. 	
    49. 	//6、int rfind(const char* s, int pos = npos) const;
    50. 	cout << "6、 pos = " << s.rfind(sc) << endl;
    51. 	cout << "6、 pos = " << s.rfind(sc, 12) << endl;
    52. 	
    53. 	//7、int rfind(const char* s, int pos, int n) const;  
    54. 	cout << "7、 pos = " << s.rfind(sc, 10, 2) << endl;
    55. 	
    56. 	//8、int rfind(const char c, int pos = 0) const;  
    57. 	cout << "8、 pos = " << s.rfind('p') << endl;
    58. 	cout << "8、 pos = " << s.rfind('p', 15) << endl;
    59. 	
    60. 	//9、string & replace(int pos, int n, const string & str);
    61. 	s.replace(5, 5, sf);
    62. 	cout << "9、s = " << s << endl;
    63. 	
    64. 	//10、string & replace(int pos, int n, const char* s);
    65. 	s.replace(5, 2, "happy");
    66. 	cout << "10、s = " << s << endl;
    67. 	
    68. 	system("pause");
    69.  
    70. 	return 0;
    71. }

    输出结果

    1、 pos = 5
    1、 pos = 5
    1、未找到时， pos = -1
    2、 pos = 2
    2、 pos = 2
    3、 pos = 13
    4、 pos = 2
    4、 pos = 13
    5、 pos = 33
    5、 pos = 5
    6、 pos = 13
    6、 pos = 2
    7、 pos = 2
    8、 pos = 36
    8、 pos = 8
    9、s = I am ha,I am working now with happiness.
    10、s = I am happy,I am working now with happiness.

    3.5、string字符串比较

    字符串比较是按字符的ASCII码进行比较的，相等=返回0， 大于>返回1，小于<返回-1，函数原型如下：

    • int compare(const string& s) const;
    • int compare(const char* s) const;
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - string - 字符串比较
    8. 	/*函数原型：
    9. 		1、int compare(const string& s) const;
    10. 		2、int compare(const char* s) const;
    11. 	*/
    12.  
    13. 	string s = "I am happy";
    14. 	string s1 = "I am happy";
    15. 	string s2 = "I am happy.";
    16. 	string s3 = "I am busy.";
    17. 	//1、int compare(const string& s) const;
    18. 	cout << "1、比较结果：" << s.compare(s1) << endl;
    19. 	cout << "1、比较结果：" << s.compare(s2) << endl;
    20. 	cout << "1、比较结果：" << s.compare(s3) << endl;
    21.  
    22. 	//2、int compare(const char* s) const;
    23. 	cout << "2、比较结果：" << s.compare("I am happy") << endl;
    24. 	cout << "2、比较结果：" << s.compare("I am happy.") << endl;
    25. 	cout << "2、比较结果：" << s.compare("I am busy") << endl;
    26.  
    27. 	system("pause");
    28.  
    29. 	return 0;
    30. }

    输出结果

    1、比较结果：0
    1、比较结果：-1
    1、比较结果：1
    2、比较结果：0
    2、比较结果：-1
    2、比较结果：1

    3.6、字符存取 

    string中单个字符存取有两种方式：

    • char& operator[](int n); //通过[]运算符重载方式取获取字符
    • char& at(int n);             //通过at方法获取字符
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - string - 字符存取
    8. 	/*函数原型：
    9. 		1、char& operator[](int n); //通过[]运算符重载方式取获取字符
    10. 		2、char& at(int n);         //通过at方法获取字符
    11. 	*/
    12.  
    13. 	cout << "---- 获取字符 ----" << endl;
    14.  
    15. 	string s = "operator";
    16. 	//1、char& operator[](int n);
    17. 	cout << "1、获取第3个字符：" << s[2] << endl;
    18.  
    19. 	//遍历所有字符
    20. 	for (int i = 0; i < s.size(); i++)
    21. 	{
    22. 		cout << s[i] << "\t";
    23. 	}
    24.  
    25. 	cout << endl;
    26.  
    27. 	//2、char& at(int n); 
    28. 	cout << "2、获取第3个字符：" << s.at(2) << endl;
    29. 	//cout << "2、获取第3个字符：" << s.at(21) << endl; //若获取越界字符，运行时将抛出异常
    30.  
    31. 	//遍历所有字符
    32. 	for (int i = 0; i < s.size(); i++)
    33. 	{
    34. 		cout << s.at(i) << "\t";
    35. 	}
    36.  
    37. 	cout << endl;
    38.  
    39.  
    40. 	cout << endl << "---- 修改字符 ----" << endl;
    41. 	s[3] = 'x';
    42. 	cout << "1、修改后字符串 = " << s << endl;
    43.  
    44. 	s.at(5) = 'y';
    45. 	cout << "2、修改后字符串 = " << s << endl;
    46.  
    47. 	system("pause");
    48.  
    49. 	return 0;
    50. }

    输出结果

    ---- 获取字符 ----
    1、获取第3个字符：e
    o       p       e       r       a       t       o       r
    2、获取第3个字符：e
    o       p       e       r       a       t       o       r

    ---- 修改字符 ----
    1、修改后字符串 = opexator
    2、修改后字符串 = opexayor

    3.7、string插入和删除

    函数原型：

    插入：

    • string& insert(int pos, const char* s);       //插入字符串
    • string& insert(int pos, const string& str);  //插入字符串
    • string& insert(int pos, int n, char c);        //在指定位置插入n个字符c

    删除：

    • string& erase(int pos, int n= npos);         //删除从pos开始的n个字符

     

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - string - 插入和删除
    8. 	/*函数原型：
    9. 	  插入：
    10. 		1、string& insert(int pos, const char* s);       //插入字符串
    11. 		2、string& insert(int pos, const string& str);  //插入字符串
    12. 		3、string& insert(int pos, int n, char c);      //在指定位置插入n个字符c
    14. 	  删除：
    15. 		4、string& erase(int pos, int n= npos);         //删除从pos开始的n个字符
    16. 	*/
    17. 	string s = "happy";
    18. 	string si = " too.";
    19. 	//1、string& insert(int pos, const char* s);
    20. 	s.insert(0, " am ");
    21. 	cout << "1、s = " << s << endl;
    22.  
    23. 	//2、string& insert(int pos, const string& str);
    24. 	s.insert(9, si);
    25. 	cout << "2、s = " << s << endl;
    26.  
    27. 	//3、string& insert(int pos, int n, char c); 
    28. 	s.insert(0, 3, 'I');
    29. 	cout << "3、s = " << s << endl;
    30.  
    31. 	//4、string& erase(int pos, int n= npos); 
    32. 	s.erase(0, 2);
    33. 	cout << "4、s = " << s << endl;
    34.  
    35. 	system("pause");
    36.  
    37. 	return 0;
    38. }

    输出结果

    1、s =  am happy
    2、s =  am happy too.
    3、s = III am happy too.
    4、s = I am happy too. 

    3.8、string子串获取

    从字符串中获取想要的子串，函数原型：

    • string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	// STL - string - 子串获取
    8. 	/*函数原型：
    9. 	  	string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串	
    10. 	*/
    11. 	string s = "happy2022@gmail.com";
    12.  
    13. 	int pos = s.find("@");
    14.  
    15. 	cout << s.substr(0, pos) << endl;
    16.  
    17. 	system("pause");
    18.  
    19. 	return 0;
    20. }

    输出结果

    happy2022

  • 相关阅读:
    10款功能强大的网络嗅探工具应用分析
    Ubuntu安装Redis
    [附源码]java毕业设计家政管理系统
    认识一下什么是JSP
    Java 内置包装类——System类详解
    Web前端：程序员的最佳React开发工具
    【二】2D测量 Metrology——get_metrology_object_result_contour()算子
    删除 word 中嵌入文字下方的图片
    phantomjs-prebuilt: Running install script, failed in 32s
    痞子衡嵌入式：主流QuadSPI NOR Flash厂商关于QE位与IO功能复用关联设计
  • 原文地址：https://blog.csdn.net/ling1998/article/details/126081237