• C++学习笔记（Ⅳ）：C++提高编程

    目录

    1 模板

    1.1 模板的概念

    1.2 函数模板

    1. 语法

    2.注意事项

    3.模板案例

    4.普通函数与函数模板区别

    5.普通函数与函数模板的调用规则

    6.模板的局限性

    1.3 类模板

    1.语法

    2.类模板与函数模板的区别

    3.类模板中成员函数创建时机

    4.类模板对象做函数参数

    5.类模板与继承

    6.类模板成员函数类外实现

    7.类模板分文件编写

    8.类模板与友元

    9.类模板案例

    2 STL初始

    2.1 STL基本概念

    2.2 STL组件

    2.3 STL容器、算法及迭代器

    2.4 容器算法、迭代器初识

    1.vector存放内置数据类型

    2.vector存放自定义数据类型

    3.vector容器嵌套

    3 STL常用容器

    3.1 string容器

    1.string概念

    2.string构造函数

    3.string赋值操作

    4.string字符串拼接

    5.string查找和替换

    6.string字符串比较

    7.string存取

    8.string插入和删除

    9.string子串

    3.2 vector容器

    1.vector概念

    2.vector构造函数

    3.vector赋值操作

    4.vector容量和大小

    5.vector插入和删除

    6.vector数据存取

    7.vector互换容器

    8.vector预留空间

    3.3 deque容器

    1.deque基本概念

    2.deque构造函数

    3.deque赋值操作

    4.deque大小操作

    5.deque插入和删除

    6.deque数据存取

    7.deque排序

            3.4 案例-评委打分

    3.5 stack容器

    1.概念

    2.常用接口

    3.6 queue容器

    1.queue概念

    2.queue常用接口

    3.7 list容器

    1.list概念

    2.list构造函数

    3.list赋值和交换

    4.list大小操作

    5.list插入和删除

    6.list数据存取

    7.list反转和排序

    8.排序案例

    3.8 set/multiset容器

    1.set基本概念

    2.set构造和赋值

    3.set大小和交换

    4.set插入和删除

    5.set查找和统计

    6.set和multiset区别

    7.pair对组创建

    8.set容器排序

    3.9 map/multimap容器

    1.map概念

    2.map构造和赋值

    3.map大小和交换

    4.map插入和删除

    5.map查找和统计

    6.map容器排序

    3.10 案例-员工分组

    4 STL函数对象

    4.1 函数对象

    1.函数对象概念

    2.函数对象使用

    4.2 谓词

    1.概念

    2.一元谓词

    3.二元谓词

    4.3 内建函数对象

    1.内建函数对象

    2.算术仿函数

    3.关系仿函数

    4.逻辑仿函数

    5 STL常用算法

    5.1 常用遍历算法

    1.for_each

    2.transform

    5.2 常用查找算法

    1.find

    2.find_if

    3.adjacent_find

    4.binary_search

    5.count

    6.count_if

    5.3 常用排序算法

    1.sort

    2.random_shuffle

    3.merge

    4.reverse

    5.4 常用拷贝和替换算法

    1.copy

    2.replace

    3.replace_if

    4.swap

    5.5 常用算术生成算法

    1.accumulate

    2.fill

    5.6 常用集合算法

    1.set_intersection

    2.set_union

    3.set_difference

    1 模板

    1.1 模板的概念

    建立通用的模板，提高代码复用性

    1.2 函数模板

    ·c++还有一种利用模板的泛型编程

    1. 语法

    建立函数，其返回值类型和形参类型用虚拟类型代表

    template

    1. // 函数模板
    2. template<typename T>    //  声明一个模板，T是通用数据类型
    3. void mySwap(T &a, T &b)
    4. {
    5. 	T temp = a;
    6. 	a = b;
    7. 	b = temp;
    8. }
    9.  
    10. void test()
    11. {
    12. 	int a = 10;
    13. 	int b = 20;
    14. 	// 1.自动类型推导
    15. 	mySwap(a, b);
    16. 	mySwap<int>(a, b);
    17. 	// 2.显示指定类型
    18. 	cout << "a:" << a << endl;
    19. 	cout << "b:" << b << endl;
    20. }

    将类型参数化

    2.注意事项

    ·自动类型推导：必须推导出一致的数据类型T

    ·模板必须确定出T的数据类型才可以使用

    3.模板案例

    1. // 交换函数模板
    2. template<class T>
    3. void myswap(T &a, T &b)
    4. {
    5. 	int temp = a;
    6. 	a = b;
    7. 	b = temp;
    8. }
    9. // 排序算法
    10. template<typename T>    //  声明一个模板，T是通用数据类型
    11. void mySort(T arr[],int len)
    12. {
    13. 	for (int i = 0; i < len; i++)
    14. 	{
    15. 		int max = i;    // 认定最大值的下标
    16. 		for (int j = i+1; j < len; j++)
    17. 		{
    18. 			if (arr[max] < arr[j])   // 认定的最大值比便利出的值小
    19. 			{
    20. 				max = j;
    21. 			}
    22. 		}
    23. 		if (max != i)
    24. 		{
    25. 			myswap(arr[max], arr[i]);
    26. 		}
    27. 	}
    28. }
    29.  
    30. void test()
    31. {
    32. 	char chararr[] = "cabdjukadn";
    33. 	int num = sizeof(chararr) / sizeof(char);
    34. 	mySort(chararr, num);
    35. 	for (int i = 0; i < num; i++)
    36. 	{
    37. 		cout << chararr[i];
    38. 	}
    39. 	cout << endl;
    40. }

    4.普通函数与函数模板区别

    ·普通函数调用时可以发生隐式类型转换

    ·函数模板调用时，若利用自动类型推导，不会发生隐式类型转换

    ·若利用显示指定类型的方式，可以发生隐式类型转换（建议使用）

    5.普通函数与函数模板的调用规则

    ·若函数模板和普通函数都可以实现，优先调用普通函数

    ·可通过空模板参数列表来强制调用函数模板

    ·函数模板可以发生重载

    ·若函数模板可以产生更好的匹配，优先调用函数模板

    提供函数模板后不要提供普通函数，避免产生二义性

    6.模板的局限性

    模板不是万能的。无法实现自定义数据类型的通用化，需要利用模板重载具体化数据类型

    1. // myCompare 为模板，进行重载
    2. template<> bool myCompare(Person &a,Person &b)

    1.3 类模板

    1.语法

    与函数模板大体一致

    1. // 类模板
    2. template<class Nametype,class Agetype>
    3. class Person
    4. {
    5. public:
    6. 	Person(Nametype name, Agetype age)
    7. 	{
    8. 		this->m_name = name;
    9. 		this->m_age = age;
    10. 	}
    11. 	Nametype m_name;
    12. 	Agetype m_age;
    13. };

    2.类模板与函数模板的区别

    ·类模板中没有自动类型推导的方式

    ·类模板在模板参数列表中可以有默认参数

    3.类模板中成员函数创建时机

    ·普通成员函数一开始创建

    ·类模板中成员函数在调用时创建

    4.类模板对象做函数参数

    类模板实例化出的对象，向函数传参的方式：

    ·指定传入的类型：直接显示对象的数据类型

    1. // 类模板对象做函数参数
    2. template<class Nametype, class Agetype>
    3. class Person
    4. {
    5. public:
    6. 	Person(Nametype name, Agetype age)
    7. 	{
    8. 		this->m_name = name;
    9. 		this->m_age = age;
    10. 	}
    11. 	void showPerson()
    12. 	{
    13. 		cout << "name:" << this->m_name << endl;
    14. 		cout << "age:" << this->m_age << endl;
    15. 	}
    16. 	Nametype m_name;
    17. 	Agetype m_age;
    18. };
    19. // 1.指定传入类型
    20. void printPerson1(Personint>&p)
    21. {
    22. 	p.showPerson();
    23. }
    24. void test01()
    25. {
    26. 	Personint>p("sun", 100);
    27. 	printPerson1(p);
    28. }

    ·参数模板化：将对象中的参数变为模板进行传递

    1. // 2.参数模板化
    2. template<class Nametype,class Agetype>
    3. void printPerson2(Person&p)
    4. {
    5. 	p.showPerson();
    6. }
    7. void test02()
    8. {
    9. 	Personint>p("zhu", 99);
    10. 	printPerson2(p);
    11. }

    ·整个类模板化：将这个对象类型模板化进行传递

    1. // 3.整个类模板化
    2. template<class T>
    3. void printPerson3(T &p)
    4. {
    5. 	p.showPerson();
    6. }
    7. void test03()
    8. {
    9. 	Personint>p("sha", 90);
    10. 	printPerson3(p);
    11. }

    5.类模板与继承

    ·子类继承的父类为类模板时，子类在声明的时候，要指定父类T的类型，否则无法给子类分配内存

    1. // 类模板与继承
    2. template<class T>
    3. class Base
    4. {
    5. 	T m;
    6. };
    7. class son:public Base<int>
    8. {
    9.  
    10. };

    ·若需灵活指定父类T类型，子类需变为类模板

    1. // 类模板与继承
    2. template<class T>
    3. class Base
    4. {
    5. 	T m;
    6. };
    7. template<class T1,class T2>
    8. class son:public Base
    9. {
    10. 	T1 obj;
    11. };

    6.类模板成员函数类外实现

    类外实现时，类内只写函数声明

    1. // 类模板成员函数类外实现
    2. template<class T1,class T2>
    3. class Person
    4. {
    5. public:
    6. 	Person(T1 name, T2 age);
    7. 	void show();
    8.  
    9. 	T1 m_name;
    10. 	T2 m_age;
    11. };
    12. // 构造函数的类外实现
    13. template<class T1, class T2>
    14. Person::Person(T1 name, T2 age)
    15. {
    16. 	this->m_name = name;
    17. 	this->m_age = age;
    18. }
    19. template<class T1, class T2>
    20. // 成员函数类外实现
    21. void Person::show()
    22. {
    23. 	cout << "姓名：" << this->m_name << "年龄：" << this->m_age << endl;
    24. }

    7.类模板分文件编写

    类模板中成员函数创建时机在调用阶段，导致分文件编写时链接不到

    1. void test()
    2. {
    3. 	Personint>P("time", 20);
    4. 	P.show();
    5. }

    类的声明在头文件中，类的实现在源文件中。此时主函数中调用上述代码会报错。

    解决方法1：直接包含.cpp源文件

    1. #include
    2. using namespace std;
    3. #include
    4. #include"Person.cpp"

    解决方法2：将声明和实现写到同一个文件中，更改后缀名为.hpp

    #include"Person.hpp"

    8.类模板与友元

    全局函数类内实现：在类内声明友元

    全局函数类外实现：提前让编译器得知全局函数的存在

    1. // 让编译器提前获取类外函数
    2. template<class T1, class T2>
    3. class Person;
    4.  
    5. template<class T1, class T2>
    6. void PrintPerson(Personp)
    7. {
    8. 	cout << "姓名：" << p.m_name << "年龄：" << p.m_age << endl;
    9. }
    10. // 通过全局函数打印信息
    11. template<class T1,class T2>
    12. class Person
    13. {
    14. 	// 友元函数类外实现
    15. 	// 添加空模板的参数列表
    16. 	friend void PrintPerson<>(Personp);
    17. public:
    18. 	Person(T1 name, T2 age)
    19. 	{
    20. 		this->m_name = name;
    21. 		this->m_age = age;
    22. 	}
    23. private:
    24. 	T1 m_name;
    25. 	T2 m_age;
    26. };

    9.类模板案例

    在.hpp文件中编写类模板

    1. #pragma once
    2. #include
    3. using namespace std;
    4. #include
    5. // 通用数组类
    6. template<class T>
    7. class myArray
    8. {
    9. public:
    10. 	// 有参构造 参数 容量
    11. 	myArray(int capacity)
    12. 	{
    13. 		//cout << "有参构造调用" << endl;
    14. 		// 属性初始化
    15. 		this->m_Capacity = capacity;
    16. 		this->m_Size = 0;
    17. 		this->pAddress = new T[this->m_Capacity];    // 按照容量大小开辟堆区空间
    18. 	}
    19. 	// 拷贝构造（防止浅拷贝）
    20. 	myArray(const myArray& arr)
    21. 	{
    22. 		//cout << "拷贝构造调用" << endl;
    23. 		this->m_Capacity = arr.m_Capacity;
    24. 		this->m_Size = arr.m_Size;        // 指针不能直接赋值，否则会产生浅拷贝
    25. 		// 深拷贝
    26. 		this->pAddress = new T[arr.m_Capacity];     
    27. 		// 拷贝arr中数据
    28. 		for (int i = 0; i < this->m_Size; i++)
    29. 		{
    30. 			this->pAddress[i] = arr.pAddress[i];
    31. 		}
    32. 	}
    33. 	myArray& operator=(const myArray& arr)
    34. 	{
    35. 		//cout << "operator=调用" << endl;
    36. 		// 先判断堆区是否有数据，若有先释放
    37. 		if (this->pAddress != NULL)
    38. 		{
    39. 			delete[] this->pAddress;
    40. 			this->pAddress = NULL;
    41. 			this->m_Capacity = 0;
    42. 			this->m_Size = 0;
    43. 		}
    44. 		// 深拷贝
    45. 		this->m_Capacity = arr.m_Capacity;
    46. 		this->m_Size = arr.m_Size;
    47. 		this->pAddress = new T[arr.m_Capacity];
    48. 		// 拷贝arr中数据
    49. 		for (int i = 0; i < this->m_Size; i++)
    50. 		{
    51. 			this->pAddress[i] = arr.pAddress[i];
    52. 		}
    53. 	}
    54. 	// 尾插法
    55. 	void pushBack(const T & val)
    56. 	{
    57. 		// 判断容量是否等于大小
    58. 		if (this->m_Capacity == this->m_Size)
    59. 		{
    60. 			return;
    61. 		}
    62. 		this->pAddress[this->m_Size] = val;   // 在数组末尾插入数据
    63. 		this->m_Size++;    // 更新数组大小
    64. 	}
    65. 	// 尾删法
    66. 	void popBack()
    67. 	{
    68. 		// 让用户无法访问末尾
    69. 		if (this->m_Size==0)
    70. 		{
    71. 			return;
    72. 		}
    73. 		this->m_Size--;
    74. 	}
    75. 	// 通过下标访问数组元素
    76. 	T& operator[](int index)       // operator重载运算符[]
    77. 	{
    78. 		return this->pAddress[index];
    79. 	}
    80. 	// 返回数组容量
    81. 	int getCapacity()
    82. 	{
    83. 		return this->m_Capacity;
    84. 	}
    85. 	// 返回数组大小
    86. 	int getSize()
    87. 	{
    88. 		return this->m_Size;
    89. 	}
    90. 	
    91. 	// 析构函数
    92. 	// 释放堆区空间
    93. 	~myArray()
    94. 	{
    95. 		//cout << "析构函数调用" << endl;
    96. 		if (this->pAddress != NULL)
    97. 		{
    98. 			delete[] this->pAddress;
    99. 			this->pAddress = NULL;           // 置空防止野指针
    100. 		}
    101. 	}
    102. private:
    103. 	T * pAddress;       // 指针指向堆区开辟的真实数组
    104. 	int m_Capacity;     // 数组容量
    105. 	int m_Size;         // 数组大小
    106. };

    其中：构造函数为初始化、拷贝构造防止浅拷贝、operator=重载操作符防止浅拷贝、析构函数清空堆区内容。

    源文件

    1. #include
    2. using namespace std;
    3. #include
    4. #include"myArray.hpp"
    5. void printIntArray(myArray<int>&arr)
    6. {
    7. 	for (int i = 0; i < arr.getSize(); i++)
    8. 	{
    9. 		cout << arr[i] << endl;
    10. 	}
    11. }
    12. void test()
    13. {
    14. 	myArray<int>arr1(5);
    15. 	for (int i = 0; i < 5; i++)
    16. 	{
    17. 		arr1.pushBack(i);
    18. 	}
    19. 	printIntArray(arr1);
    20. 	cout << "arr1的容量" << arr1.getCapacity() << endl;
    21. 	cout << "arr1的大小" << arr1.getSize() << endl;
    22. 	
    23. 	myArray<int>arr2(arr1);
    24. 	printIntArray(arr2);
    25. 	arr2.popBack();
    26. 	cout << "arr2尾删后的容量" << arr2.getCapacity() << endl;
    27. 	cout << "arr12尾删后的大小" << arr2.getSize() << endl;
    28. }
    29.  
    30. int main()
    31. {
    32. 	test();
    33. 	system("pause");
    34. 	return 0;
    35. }

    2 STL初始

    2.1 STL基本概念

    1.概念：STL（standard template library，标准模板库）

    2.STL从广义上分为：容器、算法、迭代器

    3.容器和算法间通过迭代器连接

    2.2 STL组件

    1.容器：各类数据结构

    2.算法：各类常用算法

    3.迭代器：容器与算法间的桥梁

    4.仿函数：行为类似函数

    5.适配器：修饰容器或仿函数或迭代器接口

    6.空间配置器：空间配置与管理

    2.3 STL容器、算法及迭代器

    1.容器分为序列式容器（强调值的排序，序列式容器中每个元素均有固定位置）与关联式容器（二叉树结构，各元素间没有严格物理上的顺序关系）

    2.算法分为质变算法（运算期间会更改区间元素内容）和非质变算法（运算期间不会更改区间元素内容）

    3.迭代器种类

    2.4 容器算法、迭代器初识

    1.vector存放内置数据类型

    1. #include
    2. using namespace std;
    3. #include
    4. #include
    5. #include
    6. // vector容器存放内置数据类型
    7. void myPrint(int val)
    8. {
    9. 	cout << val << endl;
    10. }
    11. void test()
    12. {
    13. 	// 创建vector容器，可认为是数组
    14. 	vector<int> v;
    15. 	// 向容器中插入数据
    16. 	v.push_back(10);
    17. 	v.push_back(1200);
    18. 	v.push_back(120);
    19. 	
    20. 	// 第一种遍历方式
    21. 	// 通过迭代器访问容器中的数据
    22. 	vector<int>::iterator itBegin = v.begin();    // 起始迭代器，指向容器中首个元素
    23. 	vector<int>::iterator itEnd = v.end();        // 结束迭代器，指向容器中末尾元素的下一个位置
    24. 	while (itBegin != itEnd)
    25. 	{
    26. 		cout << *itBegin << endl;
    27. 		itBegin++;
    28. 	}
    29. 	// 第二种遍历方式
    30. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    31. 	{
    32. 		cout << *it << endl;
    33. 	}
    34. 	// 第三种遍历方式，利用遍历算法
    35. 	for_each(v.begin(), v.end(), myPrint);
    36. }

    2.vector存放自定义数据类型

    1. // vector容器存放自定义数据类型
    2. class Person
    3. {
    4. public:
    5. 	Person(string name, int age)
    6. 	{
    7. 		this->name = name;
    8. 		this->age = age;
    9. 	}
    10. 	string name;
    11. 	int age;
    12. };
    13.  
    14. void test()
    15. {
    16. 	// 创建vector容器
    17. 	vector v;
    18. 	Person p1("a", 10);
    19. 	Person p2("b", 20);
    20. 	Person p3("c", 30);
    21.  
    22. 	// 向容器中添加数据
    23. 	v.push_back(p1);
    24. 	v.push_back(p2);
    25. 	v.push_back(p3);
    26. 	
    27. 	// 通过迭代器访问容器中的数据
    28. 	for (vector::iterator it = v.begin(); it != v.end(); it++)
    29. 	{
    30. 		cout << "姓名：" <<(*it).name<< " 年龄："<<(*it).age << endl;
    31. 		// 以下相同
    32. 		//cout << "姓名：" << it->name<< " 年龄：" << it->age << endl;
    33. 	}
    34. }
    35. // 存放自定义数据类型的指针
    36. void test01()
    37. {
    38. 	// 创建vector容器
    39. 	vector v;
    40. 	Person p1("a", 10);
    41. 	Person p2("b", 20);
    42. 	Person p3("c", 30);
    43.  
    44. 	// 向容器中添加数据
    45. 	v.push_back(&p1);
    46. 	v.push_back(&p2);
    47. 	v.push_back(&p3);
    48.  
    49. 	// 遍历
    50. 	for (vector::iterator it = v.begin(); it != v.end(); it++)
    51. 	{
    52. 		cout << "姓名：" << (*it)->name << " 年龄：" << (*it)->age << endl;
    53. 	}
    54. }

    3.vector容器嵌套

    1. // vector容器嵌套
    2. void test()
    3. {
    4. 	// 创建vector容器
    5. 	vectorint>> v;
    6. 	// 创建内层容器
    7. 	vector<int> v1;
    8. 	vector<int> v2;
    9. 	vector<int> v3;
    10. 	for (int i = 0; i < 4; i++)
    11. 	{
    12. 		v1.push_back(i + 1);
    13. 		v2.push_back(i + 2);
    14. 		v3.push_back(i + 3);
    15. 	}
    16. 	// 创建外层容器
    17. 	v.push_back(v1);
    18. 	v.push_back(v2);
    19. 	v.push_back(v3);
    20. 	// 通过迭代器访问容器中的数据
    21. 	for (vectorint>>::iterator it = v.begin(); it != v.end(); it++)
    22. 	{
    23. 		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
    24. 		{
    25. 			cout << *vit;
    26. 		}
    27. 		cout << endl;
    28.  
    29. 	}
    30. }

    3 STL常用容器

    3.1 string容器

    1.string概念

    string本质上是个类，是一个char*型的容器。类内提供了多种成员方法

    2.string构造函数

    string();   默认构造

    string(const char* s);    使用字符串初始化

    string(const string str);   使用一个string对象初始化另一个string对象

    string(int n ,char c);          使用n个字符串c初始化

    3.string赋值操作

     常用前三种方式赋值

    1.     // 方法1
    2. 	string str1;
    3. 	str1 = "hello";
    4.  
    5. 	// 方法2
    6. 	string str2;
    7. 	str2 = str1;
    8.  
    9. 	// 方法3
    10. 	string str3;
    11. 	str3 = 'a';
    12.  
    13. 	// 方法4
    14. 	string str4;
    15. 	str4.assign("hello");
    16.  
    17. 	// 方法5
    18. 	string str5;
    19. 	str5.assign("hello", 4);
    20.  
    21. 	// 方法6
    22. 	string str6;
    23. 	str6.assign(str5);
    24.  
    25. 	// 方法7
    26. 	string str7;
    27. 	str7.assign(10, '7');

    4.string字符串拼接

    1. 	// 方法1
    2. 	string str1 = "hello";
    3. 	str1 += "world";
    4.  
    5. 	// 方法2
    6. 	string str2 = "!";
    7. 	str1 += str2;
    8.  
    9. 	// 方法3
    10. 	string str3 = "hello";
    11. 	str3.append("world");
    12.  
    13. 	// 方法4
    14. 	string str4 = "hello";
    15. 	str4.append("hello",4);
    16.  
    17. 	// 方法5
    18. 	string str5 = "hello";
    19. 	str5.append(str2);
    20.  
    21. 	// 方法6
    22. 	string str6;
    23. 	str6.append(str5,0,3);

    5.string查找和替换

    1. 	// 查找
    2. 	// 方法1
    3. 	string str1 = "hello";
    4. 	str1.find("l");   // 若存在返回1，否则返回-1
    5.  
    6. 	// 方法2
    7. 	str1.rfind("l");   // rfind从右往左查，find查找顺序相反
    8.  
    9. 	// 替换
    10. 	str1.replace(1,3,"11");

    6.string字符串比较

    字符串以ASCii大小进行比较，相等返回0，大于返回1，小于返回-1

    1. 	// 字符串比较
    2. 	string str1 = "hello";
    3. 	string str2 = "hello";
    4. 	if (str1.compare(str2) == 0)
    5. 	{
    6. 		cout << "相等" << endl;
    7. 	}

    7.string存取

    1. 	// 字符串存取
    2. 	string str = "hello world";
    3. 	// 方法1：通过[]访问单个字符
    4. 	for (int i = 0; i < str.size(); i++)
    5.  
    6. 	{
    7. 		cout << str[i] << endl;
    8. 	}
    9. 	// 方法2通过at方式
    10. 	for (int i = 0; i < str.size(); i++)
    11. 	{
    12. 		cout << str.at(i) << endl;
    13. 	}

    8.string插入和删除

    1. 	// 字符串插入与删除
    2. 	string str = "hello world";
    3. 	
    4. 	str.insert(1, "11");   // 插入
    5.  
    6. 	str.erase(1, 2);      // 删除

    9.string子串

    1. 	// 字符串子串获取
    2. 	string str = "hello world";
    3. 	
    4. 	string subStr = str.substr(1, 3);

    3.2 vector容器

    1.vector概念

    vector与数组类似，称为单端数组；不同于数组是静态空间，vector可以动态扩展（寻找更大的内存空间，将源数据拷贝至新空间，并释放原空间）

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

    2.vector构造函数

    创建vector容器

    1. 	vector<int> v1;     // 无参构造
    2.  
    3. 	vector<int> v2(v1.begin(), v1.end());   // 通过区间方式进行构造
    4.  
    5. 	vector<int> v3(10, 100);    // n个elem方式构造
    6.  
    7. 	vector<int> v4(v3);         // 拷贝构造

    3.vector赋值操作

    1. 	// 无参构造
    2. 	vector<int> v1;     
    3.     // operator=
    4. 	vector<int> v2;
    5. 	v2 = v1;         
    6. 	// assign
    7. 	vector<int> v3;        
    8. 	v3.assign(v1.begin(), v1.end());   
    9. 	// n个elem赋值
    10. 	vector<int> v4;  
    11. 	v4.assign(10, 100);

    4.vector容量和大小

    5.vector插入和删除

    6.vector数据存取

    7.vector互换容器

    swap可以收缩空间

    1. 	vector<int> v;  
    2. 	for (int i = 0; i < 10; i++)
    3. 	{
    4. 		v.push_back(i);
    5. 	}
    6. 	cout << v.capacity() << endl;
    7. 	cout << v.size() << endl;
    8. 	vector<int>(v).swap(v);
    9. 	cout << v.capacity() << endl;
    10. 	cout << v.size() << endl;

    8.vector预留空间

    减少vector在动态扩展容量时的扩展次数 

    3.3 deque容器

    1.deque基本概念

    双端数组，可以对头端进行插入删除操作

    2.deque构造函数

    3.deque赋值操作

    4.deque大小操作

    5.deque插入和删除

    6.deque数据存取

    7.deque排序

    需包含算法头文件

    对于支持随机访问的迭代器的容器（vector），都可利用sort算法直接对其排序。

    3.4 案例-评委打分

    1. // 选手类
    2. class Person
    3. {
    4. public:
    5. 	Person(string name, int score)
    6. 	{
    7. 		this->m_name = name;
    8. 		this->m_score = score;
    9. 	};
    10. 	string m_name;
    11. 	int m_score;
    12. };
    13. // 创建选手
    14. void creatPerson(vector &v)
    15. {
    16. 	string nameSeed = "ABCDE";
    17. 	for (int i = 0; i < 5; i++)
    18. 	{
    19. 		string name = "选手";
    20. 		name += nameSeed[i];
    21. 		int score = 0;
    22. 		
    23. 		Person p(name, score);
    24. 		// 将创建的person对象，放入到容器中 
    25. 		v.push_back(p);
    26. 	}
    27. }
    28. // 打分函数
    29. void setScore(vector &v)
    30. {
    31. 	for (vector::iterator it = v.begin(); it != v.end(); it++)
    32. 	{
    33. 		deque<int> d;
    34. 		for (int i = 0; i < 10; i++)
    35. 		{
    36. 			int score = rand() % 41 + 60;
    37. 			d.push_back(score);
    38. 		}
    39. 		// 排序
    40. 		sort(d.begin(), d.end());
    41. 		// 去除最高与最低分
    42. 		d.pop_back();
    43. 		d.pop_front();
    44. 		// 取平均分
    45. 		int sum = 0;
    46. 		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
    47. 		{
    48. 			sum += *dit;
    49. 		}
    50. 		int avg = sum / d.size();
    51. 		// 赋值给选手
    52. 		it->m_score = avg;
    53. 	}
    54. }
    55. // 显示得分
    56. void showScore(vector &v)
    57. {
    58. 	for (vector::iterator it = v.begin(); it != v.end(); it++)
    59. 	{
    60. 		cout << "姓名：" << it->m_name << " 平均分："<< it->m_score << endl;
    61. 	}
    62. }

    3.5 stack容器

    1.概念

    stack是一种先进后出的数据结构，只有一个出口。栈不允许有遍历行为

    2.常用接口

    3.6 queue容器

    1.queue概念

    queue是一种先进先出的数据接口，只有队头和队尾才可被访问，不可遍历。

    2.queue常用接口

     

    3.7 list容器

    1.list概念

    ·将数据进行链式存储

    ·链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。

    ·链表由一系列结点组成，结点一个是存储数据元素的数据域，另一个是村查下一个结点地址都指针域

    ·STL中的链表是一个双向循环链表

    ·可以对任意位置进行快速插入或删除元素，但遍历速度没有数组快，且占用空间比数组大

     链表中的迭代器只支持前移和后移，属于双向迭代器；

    2.list构造函数

    3.list赋值和交换

    4.list大小操作

    5.list插入和删除

    6.list数据存取

    list不能用[]与at方式访问元素，迭代器不支持随机访问

    7.list反转和排序

    8.排序案例

    1. // 类定义
    2. class Person
    3. {
    4. public:
    5. 	Person(string name,int age,int height)
    6. 	{
    7. 		this->m_name = name;
    8. 		this->m_age = age;
    9. 		this->m_height = height;
    10. 	}
    11. 	string m_name;
    12. 	int m_age;
    13. 	int m_height;
    14. };
    15. // 排序规则
    16. bool comparePerson(Person &p1, Person &p2)
    17. {
    18. 	if (p1.m_age == p2.m_age)
    19. 	{
    20. 		return p1.m_height > p2.m_height;
    21. 	}
    22. 	return p1.m_age < p2.m_age;
    23. }
    24. void test()
    25. {
    26. 	list L;
    27. 	// 准备数据
    28. 	Person p1("刘备", 35, 175);
    29. 	Person p2("曹操", 45, 180);
    30. 	Person p3("孙权", 40, 170);
    31. 	Person p4("张飞", 25, 190);
    32. 	Person p5("关羽", 35, 160);
    33. 	Person p6("赵云", 35, 200);
    34. 	// 插入数据
    35. 	L.push_back(p1);
    36. 	L.push_back(p2);
    37. 	L.push_back(p3);
    38. 	L.push_back(p4);
    39. 	L.push_back(p5);
    40. 	L.push_back(p6);
    41. 	for (list::iterator it = L.begin(); it != L.end(); it++)
    42. 	{
    43. 		cout << "姓名：" << (*it).m_name << " 年龄：" << (*it).m_age << " 身高：" << (*it).m_height<< endl;
    44. 	}
    45. 	// 排序
    46. 	cout << "排序后：" << endl;
    47. 	L.sort(comparePerson);
    48. 	for (list::iterator it = L.begin(); it != L.end(); it++)
    49. 	{
    50. 		cout << "姓名：" << (*it).m_name << " 年龄：" << (*it).m_age << " 身高：" << (*it).m_height << endl;
    51. 	}
    52. }

    3.8 set/multiset容器

    1.set基本概念

    ·所有元素在插入时被自动排序

    ·属于关联式容器，底层结构用二叉树实现

    ·不允许有重复元素

    2.set构造和赋值

    3.set大小和交换

    4.set插入和删除

    5.set查找和统计

    6.set和multiset区别

    7.pair对组创建

    成对出现的数据，利用对组可以返回两个数据

    1. // 对组的创建
    2. 	pairint>p1("tom", 20);
    3. 	cout << p1.first << p1.second << endl;
    4. 	pairint>p2 = make_pair("jerry", 30);
    5. 	cout << p2.first << p2.second << endl;

    8.set容器排序

    可以利用仿函数改变排序规则

    ·内置数据类型排序

    1. // 仿函数
    2. class mycompare
    3. {
    4. public:
    5. 	bool operator()(int v1,int v2)   // 第一个()代表重载符，第二个()代表函数参数列表
    6. 	{
    7. 		return v1 > v2;
    8. 	}
    9. };
    10. void test()
    11. {
    12. 	set<int, mycompare>s1;
    13. 	s1.insert(10);
    14. 	s1.insert(20);
    15. 	s1.insert(40);
    16. 	s1.insert(30);
    17. 	for (set<int>::iterator it = s1.begin(); it != s1.end(); it++)
    18. 	{
    19. 		cout << *it << " ";
    20. 	}
    21. 	cout << endl;
    22. }

    ·自定义数据类型排序

    1. class Person
    2. {
    3. public:
    4. 	Person(string name, int age)
    5. 	{
    6. 		this->m_name = name;
    7. 		this->m_age = age;
    8. 	}
    9. 	string m_name;
    10. 	int m_age;
    11. };
    12. class mycompare
    13. {
    14. public:
    15. 	bool operator()(const Person &p1, const Person &p2)   // 第一个()代表重载符，第二个()代表函数参数列表
    16. 	{
    17. 		return p1.m_age > p2.m_age;
    18. 	}
    19. };
    20. void test()
    21. {
    22. 	// 自定义数据类型要指定排序规则
    23. 	sets;
    24. 	Person p1("tom", 24);
    25. 	Person p2("jarry", 34);
    26. 	Person p3("luffy", 25);
    27. 	Person p4("zoro", 14);
    28. 	Person p5("sam", 55);
    29.  
    30. 	s.insert(p1);
    31. 	s.insert(p2);
    32. 	s.insert(p3);
    33. 	s.insert(p4);
    34. 	s.insert(p5);
    35.  
    36. 	for (set::iterator it = s.begin(); it != s.end(); it++)
    37. 	{
    38. 		cout << it->m_name <<  " " << it->m_age <
    39. 	}
    40. }

    3.9 map/multimap容器

    1.map概念

    ·map中所有元素都是pair

    ·pair中首个元素为key（键值），起到索引作用，第二个元素为value（实值）

    ·所有元素都会根据元素的键值自动排序

    ·map/multimap属于关联式容器，底层结构式二叉树实现

    ·可以根据key值快速找到value值

    ·map中不允许有重复key值元素

    2.map构造和赋值

     

    数据插入时要使用对组

    3.map大小和交换

    4.map插入和删除

    5.map查找和统计

    6.map容器排序

    利用仿函数可以改变排序规则

    3.10 案例-员工分组

    1. // 创建员工类
    2. class Worker
    3. {
    4. public:
    5. 	string m_name;
    6. 	int m_salary;
    7. };
    8. void creatWorker(vector &v)
    9. {
    10. 	string workerName = "ABCDEFGHIJ";
    11. 	for (int i = 0; i < 10; i++)
    12. 	{
    13. 		Worker worker;
    14. 		worker.m_name = workerName[i];
    15. 		worker.m_salary = rand()%10000 + 10000;   // 10000--19999
    16. 		v.push_back(worker);
    17. 	}
    18. }
    19. // 员工分组
    20. void setGroup(vector &v, multimap<int, Worker> &m)
    21. {
    22. 	for (vector::iterator it = v.begin(); it != v.end(); it++)
    23. 	{
    24. 		// 产生随机部门编号
    25. 		int deptId = rand() % 3;   // 0 1 2
    26. 		m.insert(make_pair(deptId, *it));
    27. 	}
    28. }
    29. void showWorker(multimap<int, Worker> &m)
    30. {
    31. 	cout << "0号部门成员：" << endl;
    32. 	multimap<int, Worker>::iterator pos = m.find(0);
    33. 	int count = m.count(0);
    34. 	int index = 0;
    35. 	for (; pos != m.end() && index < count; pos++,index++)
    36. 	{
    37. 		cout << "姓名：" << pos->second.m_name << " 工资：" << pos->second.m_salary << endl;
    38. 	}
    39.  
    40. 	cout << "1号部门成员：" << endl;
    41. 	pos = m.find(1);
    42. 	count = m.count(1);
    43. 	index = 0;
    44. 	for (; pos != m.end() && index < count; pos++, index++)
    45. 	{
    46. 		cout << "姓名：" << pos->second.m_name << " 工资：" << pos->second.m_salary << endl;
    47. 	}
    48.  
    49. 	cout << "2号部门成员：" << endl;
    50. 	pos = m.find(2);
    51. 	count = m.count(2);
    52. 	index = 0;
    53. 	for (; pos != m.end() && index < count; pos++, index++)
    54. 	{
    55. 		cout << "姓名：" << pos->second.m_name << " 工资：" << pos->second.m_salary << endl;
    56. 	}
    57. }

    4 STL函数对象

    4.1 函数对象

    1.函数对象概念

    本质上是一个类 

    2.函数对象使用

    1. // 仿函数
    2. // 可以像普通函数一样调用，可以有参数值与返回值
    3. class myAdd
    4. {
    5. public:
    6. 	int operator()(int v1, int v2)
    7. 	{
    8. 		return v1 + v2;
    9. 	}
    10. };
    11. void test01()
    12. {
    13. 	myAdd a;
    14. 	cout << a(10, 10) << endl;
    15. }
    16. // 函数对象可以有自己的状态
    17. class myPrint
    18. {
    19. public:
    20. 	myPrint()
    21. 	{
    22. 		this->count = 0;
    23. 	}
    24. 	void operator()(string test)
    25. 	{
    26. 		cout << test << endl;
    27. 		this->count++;
    28. 	}
    29. 	int count;   // 记录内部状态
    30.  
    31. };
    32. // 函数对象可以作为参数传递

    4.2 谓词

    1.概念

    2.一元谓词

    1. // 一元谓词
    2. // 仿函数
    3. class GreaterFive
    4. {
    5. public:
    6. 	bool operator()(int val)
    7. 	{
    8. 		return val > 5;
    9. 	}
    10. };
    11. void test()
    12. {
    13. 	vector<int> v;
    14. 	for (int i = 0; i <10 ; i++)
    15. 	{
    16. 		v.push_back(i);
    17. 	}
    18. 	// 查找是否存在大于5的数字
    19. 	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());

    3.二元谓词

    1. // 二元谓词
    2. // 仿函数
    3. class mycompare
    4. {
    5. public:
    6. 	bool operator()(int v1,int v2)
    7. 	{
    8. 		return v1 > v2;
    9. 	}
    10. };
    11. void test()
    12. {
    13. 	vector<int> v;
    14. 	v.push_back(10);
    15. 	v.push_back(30);
    16. 	v.push_back(20);
    17. 	v.push_back(40);
    18. 	v.push_back(50);
    19.  
    20. 	sort(v.begin(), v.end(), mycompare());
    21. 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    22. 	{
    23. 		cout << *it << endl;
    24. 	}
    25. }

    4.3 内建函数对象

    1.内建函数对象

    需要添加头文件functional

    2.算术仿函数

    实现四则运算

    1. 	// 一元仿函数
    2. 	negate<int> n;
    3. 	cout << n(50) << endl;
    4. 	// 二元仿函数
    5. 	plus<int> p;
    6. 	cout << p(10, 20) << endl;

    3.关系仿函数

    4.逻辑仿函数

    5 STL常用算法

    5.1 常用遍历算法

    ·算法头文件：algorithm、functional、numeric

    1.for_each

    2.transform

    搬运容器到另一个容器中，搬运前需要给目标容器开辟空间

    5.2 常用查找算法

    1.find

    按值查找元素

    若查找自定义数据类型，需在类中重载==运算符

    2.find_if

    按条件查找元素

    3.adjacent_find

    查找相邻重复元素

    查找指定元素是否存在

    5.count

    统计元素个数

    6.count_if

    按条件统计元素个数

    5.3 常用排序算法

    1.sort

    2.random_shuffle

    3.merge

    4.reverse

    5.4 常用拷贝和替换算法

    1.copy

    2.replace

    3.replace_if

    4.swap

    5.5 常用算术生成算法

    1.accumulate

    2.fill

    5.6 常用集合算法

    1.set_intersection

    2.set_union

    3.set_difference

     目标容器开辟空间需要从两个容器取较大值

  • 相关阅读:
    SKG 渠道中台借助 SAE + 大禹打造云原生 DevOPS，提效 60%
    2024北京智慧养老展，北京养老应用软件展，北京陪护机器人展
    Modbus TCP学习笔记
    【学习笔记】六种继承详解
    puzzle（021.3）数字消除问题
    js导出excel表格并生成多sheet（更改列宽）
    如何使用 Docker 部署 GitLab
    GPPT阅读笔记
    只需100GB内存，让Falcon 180B在你的电脑上起飞
    第一行代码 Android 第九章9.1-9.2(WebView的用法,使用HttpURLConnect发送HTTP请求，使用OkHttp发送HTTP请求）
  • 原文地址：https://blog.csdn.net/m0_49939117/article/details/127841693