C++ 基础学习

C++ 内容：

1.2 注释

1. 单行注释：//描述信息
2. 多行注释： /描述信息/

1.3 变量

变量存在的意义：方便我们管理内存空间。

变量创建的语法： 数据类型 变量名 = 变量初始值；

​ e.g. int a = 10;

相当于一个项目中只能有一个main函数

1.4 常量

作用：用于记录程序中不可更改的数据。

C++ 常量定义的两种方式

1. #define 宏常量： #define 常量名 常量值

   通常在文件上方定义，表示一个常量，不可修改

2. const 修饰的变量: const 数据类型 常量名 = 常量值

   通常在变量定义前加上关键字const, 修饰该变量为常量，不可修改。放在函数体内部。

1.5 关键字

在给变量和常量进行起名时，不要使用C++中对应的关键字，否则会产生歧义。

1.6 标识符命名规则

作用：C++规定的标识符（变量、常量）命名时，有一套自己的规则

1. 标识符不能时关键字；

   // int int = 10;

2. 标识符只能由字母、数字、下划线组成

   int abc = 10;

   int _abc = 20;

   int _123abc = 30;

3. 第一个字符必须为字母或下划线

   // int 123abc = 40;

4. 标识符中字母区分大小写

   int aaa = 100;

   cout << AAA<<endl; //AAA和aaa不一样。

   给变量起名时，最好能够起到见名知意的作用。

建议：给标识符命名时，能够清楚的表达意思，方便别人和自己阅读。

2.数据类型

C++规定在创建一个变量或者常量时，必须指定出相应的数据类型。

2.1 整型

作用：整型变量表示的是整数类型类型

数据类型 占用空间 取值范围

short(短整型) 2字节 (-2^15 ~ 2^15-1)

Int（整型） 4字节 (-2^31 ~ 2^31-1)

long(长整型) Windows为4字节， (-2^31 ~ 2^31-1)

long long（长长整型） 8字节 (-2^63 ~ 2^63-1)

e.g. int a = 10; 数据类型的存在意义；就是给变量分配一个合适的内存空间，不造成资源浪费。

整型： 占用空间越大，所表示的数的范围就越大。

2.2 sizeof 关键字

作用：统计数据类型所占内存大小。

语法：sizeof（数据类型/变量）

整型大小比较

//short < int <=long <long long 因为long型可能是不在windows系统下的。

2.3 实型（浮点型）

作用：用于表示小数。

浮点型变量分为两种：

1. 单精度的 float 4字节 7位有效数字

2. 双精度的 double 8字节 15-16位有效数字

   表示有效数字范围不同。

   默认情况下的小数都是双精度的。e.g. 3.14表示双精度数字。

   想要表示单精度的数字则在后边加上f e.g. 3.14f 表示单精度数字

   //科学计数法
   float f2 = 3e2; //3 * 10^2;
   float f3 = 3e-2;
   cout << “f2=” << f2 << endl;
   cout << “f3=” << f3 << endl;

2.4 字符型

作用：字符型变量用于显示单个字符。

语法： char ch = ‘a’;

注意1：在显示字符型变量时，用单引号将字符括起来，不用双引号。

注意2： 单引号内只能有一个字符，不能时字符串。

C/C++中字符型变量只占用一个字节。

字符型变量并不是把字符本身放到内存中存储，而是存储的对应ASCII码。

/* 1. 字符型变量的创建方式
*  2. 字符型变量所占内存大小
*  3. 字符型变量常见的错误 
*			创建字符型变量时，只能用单引号，单引号内只能有一个字符。
*			
*  4. 字符型变量对应的ASCII编码。
*			直接使用强制转换函数int，将其转换为整数类型得到对应的ASCII码。
*/ 
char ch1 = 'g';
cout << "ch1=" << ch1 << endl;
cout << "该字符的ASCII码" << (int)ch1 << endl;
cout << "char 类型所占内存空间为：" << sizeof(ch1) << endl;
return 0;

a 对应的ASCII码是97。

A 对应的ASCII码是65。

0-31是控制字符，32-126分配给了键盘上能够找到的字符。

2.5 转义字符。

作用：用于表示一些不能显示出来的ASCII字符。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1WcRrDcZ-1685672196897)(F:\Desktop\C++\fig\微信图片_20230402160734.png)]

常用的转意字符 \t 水平制表 \n 换行 \ \ 表示 “\”字符。

/* 转义字符  \t 制表符，它和前边的总共加起来占8个位  \n换行   \\  输出反斜杠
*/
string str1= "aaaa";
cout <<str1 <<endl;
cout << "aaaaa\t Hello" << endl;
cout << "aaa\t Hello"<< endl;
cout << "aaaaaaa\t Hello" << endl;
cout << "aaa\nHello" << endl;
cout << "aaaaaa\\ Hello" << endl;

2.6字符串类型

C 风格的字符串： char 变量名[] = “字符串值”

C++ 风格的字符串： string 变量名 = ”字符串值“

/*字符串
*/
//C++  需要包含一个头文件  <string>
string str2 = "aaaa";
cout << str2 << endl;
//C风格  1.注意变量名后边的 [] 不能少。2.注意等号后的值要用双引号引起来。
char str3[] = "Hello world!";
cout << str3 << endl;

2.7 布尔类型

作用是返回真假

bool类型只有两个值

1. true —真（1）
2. false —假（0）

bool类型只占用一个字节大小。

// 1.创建bool数据类型
bool flag = true; 
cout << flag <<endl;
flag = false;
cout << flag << endl;
//2. 查看bool类型所占的内存空间
cout << "size of bool:"<<sizeof(flag)<<endl;

2.8数据输入

作用：从键盘获取数据

关键字: cin

语法： cin >> 变量

// 1. 整型
int aw = 0;
cout << "Plese input int variable:" << endl;
cin >> aw;
cout << "Int variable aw=" << aw << endl;

3.运算符

作用：用于执行代码的运算

主要运算符如下：

算数运算符 用于处理四则运算 除法：3/2 两个整数相除依然是整数，且是向下取整。 % 取模（余数）运算，小数不能取模。

​ 递增运算符 ++

// 1. 前置递增
int d = 10;
++d;
cout << "d = " << d << endl;
//2.后置递增
d++;
cout << "d=" << d << endl;
//3. 前置和后置的区别
//   前置递增会先让表达式+1，然后进行表达式的运算。
//   后置递增，先进行表达式的运算，再让变量+1；
int a1 = 10;
int b1 = ++a1 * 10;
int a2 = 5;
int b2 = a2++ * 10;
cout << "a2=" << a2 << endl;
cout << "b2=" << b2 << endl;
cout << "a1=" << a1 << endl;
cout << "b1=" << b1 << endl;

​ 递减运算符 –

赋值运算符 用于将表达式的值赋值给变量 +=， -=，*=，/=，%=

比较运算符 用于表达式的比较，并返回一个真值或者一个假值 ==，!=，<=, >=, 优先级运算加（）

逻辑运算符 用于根据表达式的值返回真或者假。

！逻辑非(真假取反)，&& 逻辑与（二者都为真则返回1，否则返回0）， || 逻辑或（二者中有一个为真则返回真，都为假返回假。）

4.程序流程结构

C/C++支持基本的三种程序运行结构：顺序结构、选择结构、循环结构

顺序结构：程序按照顺序执行，不发生跳转

选择结构：依照条件是否满足，有选择的执行相应功能。

循环结构：依照条件是否满足，循环多次执行某段代码。

4.1 选择结构

4.1.1 if 语句

作用：执行满足条件的语句

if 语句的三种形式

1. 单行格式if语句：if (条件) {条件满足时执行的语句} // 注意if语句没有分号。

2. 多行格式if语句：if (条件) {条件满足时执行的语句}else{条件不满足执行语句}

3. 多条件的if语句：if (条件1) {条件1满足时执行的语句}else if(条件2){条件2满足执行的语句}else{条件都不满足执行语句}

4. 嵌套 if语句：作用：达到更加精确的条件判断

   案例需求：1. 提示用户输入一个高考考试分数，根据分数做出如下判断。

   2. 分数如果大于600视为考上一本，大于500视为考上二本，大于400视为考上三本。其余视为未 考上本科。

   3. 再一本分数中如果大于700分，考入清北，大于650分考入人大，大于750视为非法输入。

      注意：在进行实现时，要考虑分数从上往下的情况依次是什么！不要漏掉分数段。

案例需求：三只小猪称体重，有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪只小猪的体重最重？

			1. 输入三只小猪的体重。
			2. 提示用户小猪的体重为多少
                    				3. 进行判断哪只小猪最重。

4.1.2三目运算符：

作用：通过三目运算符实现简单的判断。

语法：表达式1 ？表达式2 ： 表达式3

解释：如果表达式1的值为真，执行表达式2，并返回表达式2的结果；

​ 如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

4.1.3 switch语句

作用：执行多条件分支语句

语法：

switch (表达式){ //该表达式只能为整数或者是一个字符型。

case 结果1： 执行语句； break;

case 结果2： 执行语句； break;

…

default : 执行语句；break;

}

如果在某一个case 里边有很多行代码，那么将其用{}括起来，组成代码段。不会报错。

/* Switch语句 给电影打分
* 10~9   经典电影
* 8-7   非常好的电影
* 6-5   一般电影
* 5以下   烂片不好
*/
int score_movie = 0;
cout << "请输入你对本电影的打分结果：" << endl;
cin >> score_movie;
cout << "你输入的电影打分结果是： " << score_movie << "分"<<endl;
switch (score_movie) {// 根据score_movie结果进行case转换。
case 10 : 
	cout << "你认为是经典电影！" << endl; break;
case 9:
	cout << "你认为是经典电影！" << endl; break;
case 8:
	cout << "你认为是非常好的电影！" << endl; break;
case 7:
	cout << "你认为是非常好的电影！" << endl; break;
case 6:
	cout << "你认为是一般电影！" << endl; break;
case 5:
	cout << "你认为是一般电影！" << endl; break;
default: //表示前边的case都不满足执行此语句。
	cout << "你认为这个电影不好！" << endl; break;
}

if 和 switch的区别？

switch的缺点，表达式在执行判断的时候只能是整型或者是字符型，不能是一个区间

​ 优点，结构清晰，执行效率高。

4.2 循环结构

4.2.1 while

作用：满足循环条件时，执行循环语句。

语法：while (循环条件) {循环执行语句} //循环条件为真执行循环语句。

练习案例 猜数字：

案例描述：系统随机生成一个1-100之间的随机数，玩家进行猜测，如果猜错，提示玩家数字过大或者过小，如果猜对，恭喜玩家胜利并退出游戏。

#include <ctime>  //使用time函数前必须加入这个头文件。
//添加随机数的种子，作用是利用当前系统时间生成随机数，防止每次的随机数都一样。
srand((unsigned int)time(NULL));//添加随机种子的语法。
int	num1 = rand() % 100 + 1;  //rand()%100 生成0-99的一个随机数
int freuency = 0;
int num2 = 0;
cout << "请输入你猜测的随机数：" << endl;
while (1 && freuency < 5) {
	cin >> num2;
	cout << "你猜测的数字为:" << num2 << endl;
	if (num1 > num2) {
		cout << "你猜测的数字偏小" << endl;
		freuency++;
	}
	else if (num1 < num2) {
		cout << "你猜测的数字偏大" << endl;
		freuency++;
	}
	else {
		cout << "恭喜你猜对了！" << endl;
		break;  //break,可以用来退出当前循环。
	}
	if (freuency == 5) {
		cout << "猜测次数达到上限，游戏终止。" << endl;
	}
}

system("pause");
return 0;

4.2.2 do …while 循环语句

作用：满足循环条件，执行循环语句。

语法: do {循环语句} while（循环条件）；

区别：与While语句的区别在于do … while会先执行一次循环语句，再进行判断循环条件是否满足。

练习案例：

案例描述：水仙花数是指的一个三位数，它的每个位上的数字的3次幂之和等于它本身。

e.g. $1^3+5^3+3^3$ = 153

请利用一个do …while，求出所有三位数中的水仙花数字。

分析：1. 从键盘上输入一个三位数，

​ 2. 利用取模运算分别得到相应的个位数，十位数，百位数数字

		3. 进行三次方运算，求和
        			4. 判断是否和原数字相等。

int num3 = 100;
int Hundreds = 0;
int decade = 0;
int Unit = 0;
int new_num = 0;
do {
	Hundreds = num3 / 100;
	decade = (num3 / 10) % 10;
	Unit = num3 % 10;
	new_num = pow(Hundreds,3) + pow(decade,3) + pow(Unit,3);
	if (new_num == num3) {
		cout << "This number is shuixianhua number." <<num3<< endl;
	}
	num3++;
} while (num3 < 1000);

4.2.3 for循环语句

作用: 满足循环条件，执行循环语句

语法： for（起始表达式；条件表达式；末尾循环体）{循环语句；}

#include <iostream>
#include <string>
#include <ctime>
#include <math.h>
using namespace std;

int main(){
for (int i = 0;i<10;i++){
cout<< i<<endl;
}
system("pause");
return 0;
}

总结：for 循环的表达式中，要用分号进行分隔；

案例练习：敲桌子

案例描述：从1开始数到数字100，如果数字各位含有7，或者数字十位含有7，或者数字是7的倍数，我们敲桌子，其余数字直接打印输出。

int flag = 0;
int decade = 0;
int unit = 0;
for (int i = 1; i <= 100; i++) {
	decade = i / 10;
	unit = i % 10;
	if (i % 7 == 0) { cout << "Plese knock this table." << endl; flag++; }
	else if (decade == 7) { cout << "Plese knock this table." << endl; flag++; }
	else if (unit == 7) { cout << "Plese knock this table." << endl; flag++; }
	else {
		cout << "输出数字:" << i << endl;
		cout << "总共敲击桌子次数为：" << flag << endl;
	}

4.2.4 嵌套循环

作用：在循环体中再嵌套一层循环，解决一些实际问题。

for (int j = 0; j < 10; j++) {
	for (int i = 0; i < 10; i++) {
		cout << "* ";
	}
	cout << endl;
}

打印乘法表

//打印乘法表
for (int k = 1; k < 10; k++) {
	for (int n = 1; n < 10; n++) {
		if (n <= k) {
			cout << n << " × " << k<<"="<<k*n<<" ";
		}
		else { cout << endl;
				break;
		}
	}
}

4.3 跳转语句

4.3.1 break语句

作用：用于跳出选择结构或者循环结构

break使用的时机

	1. 出现switch条件语句中，作用是终止case并跳出switch
	2. 出现在循环语句中，作用是跳出当前的循环语句
            		3. 出现在嵌套循环语句中，跳出最近的内层循环语句。

4.3.2 continue语句中

作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续下一次循环。

continue是执行到本行时，不再执行后边的代码，再进行下一次循环，而break语句是直接跳出循环，不再进行循环了。

4.3.3 go to语句

语法：goto 标记； 解释：如果标记的名称存在，执行到goto语句中，会跳转到标记的位置。

5.数组

5.1数组：就是一个集合，里边存放了相同类型的数据元素。

特点1：数组中的每个数据元素都是相同的数据类型。

特点2： 数组是由连续的内存位置组成的。

一维数组的定义方式：

1. 数据类型 数组名[数组长度];
2. 数据类型 数组名[数组长度] = {val1,val2,…,valn};
3. 数据类型 数组名 [ ] = {val1,val2,…};

一维数组的用途：

1. 可以统计整个数组在内存中的长度。
2. 可以获取数组在内存中的首地址。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7uGjcdfV-1685672196898)(F:\Desktop\C++\fig\微信图片_20230404160837.png)]

// 数组名的用途
//1.通过数组名来统计整个数组占用内存大小。
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整个数组占用内存空间为：" << sizeof(arr) << endl;
cout << "每个元素占用内存空间为：" << sizeof(arr[0]) << endl;
cout << "数组中元素个数为：" << sizeof(arr)/sizeof(arr[0]) << endl;
//2. 可以通过数组名查看数组首地址；
cout << "数组首地址为:" << (int)arr << endl;
cout << "数组第一个元素地址为:" << (int)&arr[0] << endl;
cout << "数组第二个元素地址为:" << (int)&arr[1] << endl;
//数组名是一个常量不能进行赋值，不能修改

注意当获取某一个元素的地址的时候，需要加上一个取址符号&。

练习案例1：五只小猪的体重

案例描述：

在一个数组中记录了五只小猪的体重，如：int arr[5] = {200,450,128,120,32}

找出并打印最重的小猪体重。int max = 0; 不断更新max。

练习案例2：数组元素逆置（相当于双指针了）

案例描述：

请声明一个5个元素的数组，并且将元素逆置。

//数组元素逆置。
int array[] = { 1,4,5,7,2,3,5,4 };
int end = (sizeof(array) / sizeof(array[0])) -1;
int len1 = (sizeof(array) / sizeof(array[0]));
int start = 0;
int temp = array[0];
while(start < end) {
	temp = array[start];
	array[start] = array[end];
	array[end] = temp;
	start++; end--;
};
for (int j = 0; j < len1; j++) {
	cout << array[j];
}
cout << endl;

5.2.3 冒泡排序

作用：最常用的排序算法，对数组内元素进行排序。

1. 比较相邻的元素，如果第一个比第二个大，交换他们

2. 对每一对相邻元素做相同的工作，执行完毕后找到一个最大值

3. 重复以上步骤，每次比较次数-1，直到不需要比较。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X8ZkUFgC-1685672196899)(F:\Desktop\C++\fig\fc788aab1c3f5c5cfa80ae0f001f50b.png)]

5.3 二维数组

二维数组定义方式：

1. 数据类型 数组名【行数】【列数】；

   int arr[2][3];
   arr[0][0] = 0;arr[0][1] = 1;arr[0][2] = 2;
   arr[1][0] = 3;arr[1][1] = 4;arr[1][2] = 5;
   for (int i = 0;i<2;i++){
   	for (int j = 0; j<3; j++){
   	cout<<arr[i][j];
   	}
   	cout<<endl;
   }
   

2. 数据类型 数组名【行数】【列数】= {{num1,num2}，{num3,num4}}；

   int arr2[2][3] = {{1,2,3}, {4,5,6}};
   for (int i = 0;i<2;i++){
   	for (int j = 0; j<3; j++){
   	cout<<arr2[i][j];
   	}
   	cout<<endl;
   }
   

3. 数据类型 数组名【行数】【列数】 = {num1,num2,num3,num4};

   int arr3[2][3] = {{1,2,3,4,5,6}};
   for (int i = 0;i<2;i++){
   	for (int j = 0; j<3; j++){
   	cout<<arr3[i][j]<<" ";
   	}
   	cout<<endl;
   }
   

4. 数据类型 数组名【】【列数】 = {num1,num2,num3,num4};

   int arr4[][3] = {{1,2,3,4,5,6}};
   for (int i = 0;i<2;i++){
   	for (int j = 0; j<3; j++){
   	cout<<arr4[i][j]<<" ";
   	}
   	cout<<endl;
   }
   

利用第二种定义方式，更加直观，提高代码的可读性。

5.3.2二维数组的数组名

1. 可以查看二维数组所占的内存空间

   cout<<"二维数组所占用的内存空间："<<sizeof(arr)<<endl;
   cout<<"二维数组第一行所占用的内存空间："<<sizeof(arr[0])<<endl;
   row = sizeof(arr)/sizeof(arr[0]);
   cout<<"二维数组第一个元素所占用的内存空间："<<sizeof(arr[0][0])<<endl;
   col = sizeof(arr[0])/sizeof(arr[0][0]);
   

2. 获取二维数组首地址

cout<<"二维数组首地址："<<(int)arr<<endl;
cout<<"二维数组第一行首地址："<<(int)arr[0]<<endl;
cout<<"二维数组第二行首地址："<<(int)arr[1]<<endl;
cout<<"二维数组第一个元素首地址："<<(int)&arr[0][0]<<endl;  //因为arr[0][0]是一个数，所以想要看地址需要加上一个取地址符&。

5.3.3二维数组应用案例

考试成绩统计：

案例描述：有三位同学 AA,BB,CC 在一次考试中的成绩如下表，分别输出三名同学的总成绩。

​ 语文 数学 英语

AA 100 100 100

BB 90 50 100

CC 60 70 80

6.函数

6.1 概述

作用：将一段经常使用的代码封装起来，减少重复代码的出现

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

6.2函数的定义

函数定义的一般主要步骤为5个:

1. 返回值类型 : 一个函数可以返回一个值，在函数定义中
2. 函数名：给函数起一个名
3. 参数列表：使用该函数时，传入的数据
4. 函数体语句：花括号内的代码，函数需要执行的语句
5. return 表达式：和返回值类型挂钩，函数执行完后，返回相应的数据类型。

语法：

返回值类型 函数名 （参数列表）
{
	函数体语句

	return表达式
}

int add(int num1,int num2){
	int sum = num1+num2;
	return sum;
}

6.3函数调用

功能：使用定义好的函数

语法：函数名（参数）

6.4值传递

所谓值传递，就是函数调用时实参将数值传入给形参。

值传递时，如果形参发生任何改变，并不会影响实参。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7HrbVJnX-1685672196899)(F:\Desktop\C++\fig\36a687bda206b6ddf8ae206a7088068.png)]

6.5函数的常见样式。

常见的函数样式有4种

1. 无参无返
2. 有参无返
3. 无参有返
4. 有参有返

#include <iostream>
using namespace std;

//1.无参无返
void test01(){
cout<<"This is test01"<<endl;
}
//2.有参无返
void test02(int a){
cout<<"This is test02, a = "<<a<<endl;}
//3.无参有返
int test03(){
	cout<<"This is test03"<<endl;
	return 100;
}
//4.有参有返
int test04(int a){
	cout<<"This is test04, a = "<<a<<endl;
	return a
}

6.6 函数的声明

作用：告诉编译器函数名称如何调用函数，函数的实际主体可以单独定义。

#include<iostream>
#include<string>
#include<math.h>
#include<ctime>
using namespace std;

//函数声明,函数声明必须在前边
int max(int a, int b);

//函数主体，函数主体可以在前边，可以在后边，当在后边时，前边必须协商函数声明，让编译器知道有这个函数，不报错。
int max(int a, int b){
	return a > b ? a : b
}
int main(){
	int a = 10;
	int b = 20;
	max_val = max(a,b)
	cout<<"最大值为："<<max_val<<endl;
	system("pause");
	return 0;
}

6.7函数的分文件编写

作用：让代码结构更加清晰

函数分文件编写的4个步骤

1. 创建后缀名为.h的头文件
2. 创建后缀名为.cpp的源文件
3. 在头文件中写函数声明
4. 在源文件中写函数的定义

#include <iostream>
#include <string>
#include <ctime>
#include <math.h>
using namespace std;

//函数的分文件编写
//实现两个数字进行交换的函数

//函数的声名
void swap(int a,int b);
//函数定义
void swap(int a,int b){
	int temp = 0;
	temp = a;
	a = b;
	b = temp;
	cout <<"a = "<< a <<endl;
	cout <<"b = "<< b <<endl;
}

// 1. 创建后缀名为.h的头文件
// 2. 创建后缀名为.cpp的源文件
// 3. 在头文件中写函数声明
// 4. 在源文件中写函数的定义
int main(){
	int a = 10;
	int b = 20;
	swap(a,b);
	system("pause");
	return 0;
}

#include " 文件名" //使用双引号引入的头文件，表示该头文件是自定义的头文件。

7.指针

7.1指针的概念：可以通过指针间接访问内存。

1. 内存编号是从0开始记录的，一般用十六进制数字表示。 指针就是一个地址。
2. 可以利用指针变量保存地址

7.2 指针变量的定义和使用

//1.定义指针
int a = 10;
//指针定义的语法: 数据类型 * 指针变量名
int* p;
// 让指针记录变量a的地址
p = &a;
cout << "a的地址为:" << &a << endl;
cout << "指针p为：" << p << endl;


//2.使用指针
//可以通过解引用的方式来找到指针指向的内存
// 指针前加  *  代表解引用，找到指针指向的内存中的数据
*p = 100;
cout << "a = " << a << endl;
cout << "*p = " << *p << endl;

7.3指针所占的内存空间

在32位操作系统中：指针占用4个字节的空间（无论是什么数据类型）

在64位操作系统中：指针占用8个字节的空间 （无论是什么数据类型）

7.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间。

用途：初始化指针变量。

注意：空指针指向的内存是不可以访问的。

 // 空指针
//1. 空指针用于给指针变量进行初始化
int * p = NULL;

//2. 空指针是不可以进行访问的。
//0-255之间的内存编号是系统占用的，因此不可以访问。
*p = 100;//该操作非法，因为p指针是空指针没有办法进行访问修改。
//正确做法是让指针重新指向某个元素。
//int c = 50;
//p = &c;

野指针：指针变量指向非法的内存空间。

// 野指针，在程序中，尽量避免出现野指针。
int* pp = (int*)0x1011;
cout << *p << endl;

空指针和野指针都不是我们申请的空间，因此不要访问，否则出错。

7.5 const 修饰指针

const 修饰指针有三种情况：

1. const修饰指针 ------常量指针
2. const修饰常量 ------指针常量
3. const即修饰指针，又修饰常量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-muUaoFjk-1685672196900)(F:\Desktop\C++\fig\微信图片_20230405162350.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LdwQjohP-1685672196900)(F:\Desktop\C++\fig\微信图片_20230405162356.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mNZK3LFx-1685672196901)(F:\Desktop\C++\fig\微信图片_20230405162359.png)]技巧：看const右侧紧跟的是指针还是常量。是指针就是常量指针，是常量就是指针常量。

7.6指针和数组

作用: 利用指针访问数组中的元素

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0bLWkt1f-1685672196901)(F:\Desktop\C++\fig\微信图片_20230405164736.png)]

7.7 指针和函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zMPyloZt-1685672196902)(F:\Desktop\C++\fig\微信图片_20230405165750.png)]

//实现值交换的函数
void swap01(int a, int b) {
	int temp = 0;
	temp = a;
	a = b;
	b = temp;
	cout << "swap01 a = " << a << endl;
	cout << "swap02 b = " << b << endl;
}
//实现地址交换的函数
void swap02(int* p1, int* p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() {
	int a = 10;
	int b = 20;
	//值传递
	swap01(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	//地址传递
	swap02(&a, &b);
	cout << "**********************************" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	system("pause");
	return 0;
}

7.8指针、数组、函数

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序。

e.g. int arr[10] = {4,5,2,3,4,6,3,1,75};

7.8 指针、数组、函数

封装一个函数，利用冒泡排序，实现升序排列。

#include <iostream>
using namespace std;
//冒泡排序  参数1数组的首地址，参数2数组的长度   。  要想传入数组的话就把首地址传入进来。
void bubbleSort(int * arr,int len){
	for(i = 0;i< len-1;i++){
	for(j = 0; j<len-i-1;j++){
	 //如果arr[j]>arr[j+1]那么就换位置
	 if(arr[j]>arr[j+1]){
	 int temp = arr[j];
	 arr[j] = arr[j+1];
	 arr[j+1] = temp;
	 }
	} 
	}
}
void printArray(int * arr,int len){
for(int i=0,i<len;i++){
cout<<arr[i]<<endl;
}
}

int main(){
	//1.数组的创建
	int arr[10] = {1,4,5,1,2,3,6,7,9,42};
	int len = sizeof(arr)/sizeof(arr[0]);
    //2.创建函数，实现冒泡排序
    bubbleSort(arr,len); //穿如两个参数一个是数组的首地址，一个是数组的长度
    //3.打印排序后的数组
    printArray(arr,len);
	system("pause");
	return 0;
}

8.结构体

8.1结构体的基本概念

结构体属于用户自定义的数据类型，允许用户存储不用的数据类型。

8.2结构体定义和使用

语法：struct 结构体名（结构体成员列表）：

通过结构体创建变量的方式有三种：

1. struct 结构体 变量名
2. struct 结构体 变量名 = {成员1值，成员2值}
3. 定义结构体时顺便创建变量

数据类型：整型，浮点型，字符型，bool类型，字符串类型。

#include <iostream>
#include <string>
using namespace std;
//1. 创建学生数据类型，学生包括（姓名，年龄，分数）
//自定义数据类型，一些类型结合组成的一个类型。
struct Student{
	//	成员列表
	//1.姓名
	string name;
	//2. 年龄
	int age;
	//3.分数
	int score;
}s3;
//2. 通过学生类型创建具体的学生。

//2.1 struct Student s1
//2.2 struct Student s2 = {...}
//2.3 定义结构体时顺便创建变量
int main(){
	//2.1 struct Student s1
	//在结构体变量创建时，struct 关键字可以省略，在定义时不能省去。
	struct Student s1;
	//给s1属性进行复制，通过  点  访问结构体变量中的属性。
	s1.name = "张三";
	s1.age = 20;
	s1.score = 100;
	
	cout<<"姓名："<<s1.name<<" 年龄："<<s1.age <<" 分数："<<s1.score<<endl;
	//2.2 struct Student s2 = {...}
 	struct Student s2 = {"李四",25,98};
 	cout<<"姓名："<<s2.name<<" 年龄："<<s2.age <<" 分数："<<s2.score<<endl;
 	//2.3 定义结构体时顺便创建变量,也就是在结构体定义后边直接实例化 加上 s3
    s3.name = "张三";
	s3.age = 20;
	s3.score = 100;
 	cout<<"姓名："<<s3.name<<" 年龄："<<s3.age <<" 分数："<<s3.score<<endl;
 	
	system("pause");
	return 0;
}

8.3 结构体数组

作用：将自定义结构体放到数组中方便维护。

语法：struct 结构体名 数组名（元素个数） = {{}，{}，{}，…}

#include <iostream>
using namespace std;
#include <string>
//结构体数组
//1.定义一个结构体
//2.创建一个结构体数组
//3.给结构体中数组元素复制
//4.遍历结构体数组
struct Student{
	string name;
	int age;
	int score;
};


int main(){
	//2.创建结构体数组
	Student stuarr[3] = {
	{"漳卅",22,95}
	{"里斯",21,93}
	{"王五",33,68}
	}
	//3.给结构体数组中的元素赋值
	stuarr[2].name = "赵刘";
	stuarr[2].age = 33;
	stuarr[2].score = 60;
	//4.遍历结构体数组
	for (int i = 0;i<3;i++){
		cout<<"姓名："<<stuarr[i].name
			<<" 年龄："<<stuarr[i].age
            <<" 分数："<<stuarr[i].score<<endl;
	}
	system("pause");
	return 0;
}

8.4 结构体指针

通过指针访问结构体中的成员

利用操作符 -> 可以通过结构体指针访问结构体成员属性。

#include <iostream>
#include <string>
using namespace std;

//结构体指针
//1.定义学生结构体
struct Student{
	string name;
	int age;
	int score;
};
int main(){
	//创建学生结构体变量
	struct student s = {"李四",25,98};
	//通过指针指向结构体变量
	student * p = &s; //取s的地址时，返回的是对应的数据类型的指针
	//通过指针访问结构体变量中的数据
	//通过结构体指针访问结构体中的属性，需要利用  '->'
    cout<<"姓名："<<p->name<<" 年龄："<<p->age <<" 分数："<<p->score<<endl;
	system("pause");
	return 0;
}

8.5 结构体嵌套结构体

作用：结构体中的成员可以是另一个结构体

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体。

#include <iostream>
#include <string>
using namespace std;

struct Student{
	string name;
	int age;
	int score;
};

struct Teacher{
	string id;  //教师编号
	string name;
	int age;
	struct Student stu;
};

int main(){
	//结构体嵌套结构体
	//创建老师
	Teacher t;
	t.id = "asd125422";
	t.name = "强阿达";
	t.age = 10;
	t.stu.name = "zk";
	
	system("pause");
	return 0;
}

8.6结构体做函数参数

作用：将结构体作为参数向函数中传递

传递方式有两种：

1. 值传递
2. 地址传递

#include <iostream>
#include <string>
using namespace std;

struct student{
	string name;
	int age;
	int score;
}; 

void printstu1(struct student s1){
	s1.age = 100;
	cout<<"子函数中的姓名"<<s1.name<<"年龄："<<s1.age<<"分数"<<s1.score<<endl;
}

void printstu2(struct student * p){
	p->age = 200;
	cout<<"子函数中的姓名"<<p->name<<"年龄："<<p->age<<"分数"<<p->score<<endl;
}

int main(){
	student stu1 = {"张三",20,75};
	//利用值传递来进行打印函数
	printstu1(stu1)
	//利用地址传递来进行打印函数
	printstu2(&stu1)
	cout<<"主函数中的姓名"<<stu1.name<<"年龄："<<stu1.age<<"分数"<<stu1.score<<endl;
	system("pause");
	return 0;
}

值传递和地址传递的区别：值传递修饰形参，实参不会该变。地址传递二者都会改变。

如果不想修改主函数中的数据，用值传递，反之用地址传递。

8.7 结构体中const使用场景

#include <iostream>
#include <string>
using namespace std;

struct student{
	string name;
	int age;
	int score;
}; 
//将函数中的形参改为指针，可以减少内存空间，而且不会复新的副本出来,并且传入指针的时候可以节省空间。
void printStudent(const student *stu){
	//stu->age = 150； //加入const之后，一旦有修改的操作就会报错，可以防止我们的误操作出现。
	cout<< "姓名："<<s->name<<"年龄："<<s->age<<"得分："<<s->score<<endl;

}

int main(){
	student stu = {"张三",20,75};
	printStudent(&stu);
	system("pause");
	return 0;
}

8.8 结构体案例

案例1： 学校在做毕设项目，每名老师带领5位学生，总共3名老师，需求如下：

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员，学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值最终打印出老师数据以及老师所带的学生数据。

#include <iostream>
#include <string>
using namespace std;

struct Student{
    string sName;
    int score;
}
struct Teacher{
    string tName;
    struct Student stu[5];
}
void allocateSpace(struct Teacher tArray[],int len){
    //给老师赋值
    string = "ABCDE";
    for(int i = 0;i<len;i++){
        tArrray[i].tName = "Teacher_";
        tArrray[i].tName += nameSeed[i];
        //通过循环给每名老师所带的学生赋值
        for (int j = 0;j<5;j++){
            tArray[i].sArray[j].sName = "Student_";
            tArray[i].sArray[j].sName += nameSeed[j];
            int random = rand() % 61 + 40; // 
            tArray[i].sArray[j].score = random;
        }
        
    }
}
void printInfo(struct Teacher tArray[],int len){
    for(int i =0;i<len;i++){
        cout <<"老师姓名："<<tArray[i].tName <<endl;
        // 输出老师带的学生
        for (int j = 0;j<5;j++){
            cout <<"\t学生姓名："<<tArray[i].sArray[j].sName<<
                " 考试分数"<<tArray[i].sArray[j].score<<endl;
        }
    }
}
/* 1.创建学生结构体，然后创建老师结构体；2.
*/
int main(){
    //根据系统当前时间产生随机数种子
    srand((unsigned int)time(NULL));
    //1. 创建3名老师的数组
    struct Teacher tArray[3];
    //2. 通过函数给3名老师的信息赋值，并给老师带的学生信息赋值
    int len = sizeof(tArray) / sizeof(tArray[0]);
    allocateSpace(tArray,len);
    //3. 打印所有老师及所带的学生信息
    printInfo(tArray,len)
    system("pause");
    return 0;
}

#include <iostream>
#include <string>
#include <ctime>
using namespace std;

struct Student {
    string name;
    int score = 0;
};
struct tteacher {
    Student stu[5];
    string name;
};

void fuzhi(struct tteacher tea[],int len) {
    //给老师赋值
    string name_seed = "ABCDE";
    srand((unsigned int)time(NULL));
    for (int i = 0; i < 3; i++) {
        tea[i].name = "teacher_";
        tea[i].name += name_seed[i];
        for (int j = 0; j < 5; j++) {
            tea[i].stu[j].name = "student_";
            tea[i].stu[j].name += name_seed[j];
            int random = rand() % 61 + 40;
            tea[i].stu[j].score = random;
        }
    }
}
void printInfo(struct tteacher tArray[], int len) {
    for (int i = 0; i < len; i++) {
        cout << "老师姓名：" << tArray[i].name << endl;
        // 输出老师带的学生
        for (int j = 0; j < 5; j++) {
            cout << "\t学生姓名：" << tArray[i].stu[j].name <<
                " 考试分数" << tArray[i].stu[j].score << endl;
        }
    }
}
int main() {
    struct tteacher tea[3];
    int len = sizeof(tea) / sizeof(tea[0]);
    //int len = sizeof(tea[0].stu) / sizeof(tea[0].stu[0]);
    fuzhi(tea, len);
    printInfo(tea,len);
    return 0;
}
//出现异常

尤其要注意在一个项目中结构体不要重名

当出现越界问题时，一定要注意是不是出现了野指针，除此以外还要看是否是自己的书写上有问题。

C++继承

继承是面向对象的三大特性之一

有些类与类之间存在特殊的关系，例如下图中：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8z9T9U1p-1685672196902)(F:\Desktop\C++\fig\微信图片_20230421111624.png)]

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复的代码。

4.6.1继承的基本语法

例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同，接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义及好处。

//普通实现页面
class Java {
public:
	void header() {
		cout << "首页、公开课、登录、注册（公共头部）" << endl;
	}
	void footer() {
		cout << "帮助中心、交流合作、站内地图.......(公共底部)" << endl;
	}
	void left() {
		cout<<"Java、Python、C++、....(公共的分类列表)" << endl;
	}
	void content() {
		cout<<"Java 学科视频" << endl;
	}
};
class Python {
public:
	void header() {
		cout << "首页、公开课、登录、注册（公共头部）" << endl;
	}
	void footer() {
		cout << "帮助中心、交流合作、站内地图.......(公共底部)" << endl;
	}
	void left() {
		cout << "Java、Python、C++、....(公共的分类列表)" << endl;
	}
	void content() {
		cout << "Python 学科视频" << endl;
	}
};
class CPP {
public:
	void header() {
		cout << "首页、公开课、登录、注册（公共头部）" << endl;
	}
	void footer() {
		cout << "帮助中心、交流合作、站内地图.......(公共底部)" << endl;
	}
	void left() {
		cout << "Java、Python、C++、....(公共的分类列表)" << endl;
	}
	void content() {
		cout << "C++ 学科视频" << endl;
	}
};
void test01() {
	cout <<"Java下载视频页面" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "******************************************" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "******************************************" << endl;
	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
}

#include <iostream>
#include <string>
using namespace std;

//采用继承写页面
class BasePage {
public:
	void header() {
		cout << "首页、公开课、登录、注册（公共头部）" << endl;
	}
	void footer() {
		cout << "帮助中心、交流合作、站内地图.......(公共底部)" << endl;
	}
	void left() {
		cout << "Java、Python、C++、....(公共的分类列表)" << endl;
	}
};
//继承的好处：减少重复的代码
// 语法： class  子类  :  继承方式  父类
// 子类也称之为派生类 ，父类也称为基类。
//Java页面
class Java : public BasePage {
public:
	void content() {
		cout << "Java 学科视频" << endl;
	}
};
class Python : public BasePage {
public:
	void content() {
		cout << "Python 学科视频" << endl;
	}
};
class CPP : public BasePage {
public:
	void content() {
		cout << "C++ 学科视频" << endl;
	}
};
void test02() {
	cout <<"Java下载视频页面" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "******************************************" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "******************************************" << endl;
	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();

}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

总结：

继承的好处：可以减少重复的代码

class A : public B;

class 子类 : 继承方式 父类

子类也称之为派生类 ，父类也称为基类。

派生类中的成员，包含两大部分：

一类时从基类继承过来的，一类时自己增加的成员。

从基类继承过来的表现其共性，而新增的成员体现其个性。

4.6.2继承方式

1. 公共继承
2. 保护继承
3. 私有继承

#include <iostream>
#include <string>
using namespace std;

//继承方式
//1.公共继承
//2.保护继承
//3.私有继承

class Base1 
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son1 :public Base1 {
public:
	void func() 
	{
		m_A = 10; //父类中公共权限的成员，到子类中依然是公共权限。
		m_B = 10;//父类中保护权限的成员，到子类中依然是保护权限。
		//m_C = 10;//父类中私有权限的成员，子类访问不到。
	}
};
void test03() {
	Son1 s1;
	s1.m_A = 100; 
	//s1.m_B = 100;//到Son1中，m_B是保护权限 类外访问不到
}
class Son2 : protected Base1 {
public:
	void func() 
	{
		m_A = 100;
		m_B = 100;
		//m_C = 100; //父类中私有权限的成员，子类访问不到。
	}
};
void test04() 
{
	//Son2 s1;
	//表明了在父类中的m_A由公有变为保护属性，在儿子中不能访问
	//s1.m_A = 100;
	//s1.m_B = 100;

}
class Son3 : private Base1 {
public:
	void func()
	{
		m_A = 100;
		m_B = 100;
		//m_C = 100; //父类中私有权限的成员，子类访问不到。
	}
};
void test05()
{
	//Son3 s1;
	//由于是私有继承，因此继承过来的所有属性都变为了私有，不能访问。
	//s1.m_A = 100;
	//s1.m_B = 100;

}
class GrandSon3 : private Son3 {
public:
	void func()
	{
		//m_A = 100;//由于父类Son3把Base1类继承过来后所有属性值都变为私有的了，因此再将Son3作为父类再进行继承的时候就继承不了上述Son3的属性了。
		//m_B = 100;
		//m_C = 100; //父类中私有权限的成员，子类访问不到。
	}
};
int main() {
	test03();
	system("pause");
	return 0;
}

4.6.3继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象。

#include<iostream>
#include <string>
using namespace std;

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
}; 
class Son :public Base {
public:
	int m_D;
};
//用开发人员命令提示工具查看对象模型
//跳转盘符：F：（要查看的文件是在哪个盘符下就跳转哪个盘符）
//跳转文件路径 cd 具体路径下
//查看命名
//cl /d1 reportSingleClassLayout类名 文件名   （c(后边的是字母l）d(后边的是数字1))  可以查看某个类的具体结构信息，哪些是继承过来的，哪些是自身独有的。



void test06() {
	//父类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性是被编译器给隐藏了，因此是访问不到的，但是确实被继承下去了。
	cout<<"size of Son = " << sizeof(Son) << endl;  //16字节
}
int main() {
	test06();
	system("pause");
	return 0;
}

结论：父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到。

4.6.4继承中的构造和析构的顺序

子类继承父类后，当创建子类对象时，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序时谁先谁后？

#include <iostream>
#include <string>
using namespace std;
//继承中的构造和析构顺序
class Base2 
{
public:
	Base2() 
	{
		cout << "Base构造函数！" << endl;
	}
	~Base2() {
		cout << "Base析构函数！" << endl;
	}
};
class SON :public Base2 {
public:
	SON()
	{
		cout << "Son构造函数！" << endl;
	}
	~SON() {
		cout << "Son析构函数！" << endl;
	}
};
void test07() {
	//Base2 b;
	//继承中的构造和析构的顺序如下：
	//先构造父类，再构造子类，析构的顺序和构造的顺序相反。
	SON s;
}
int main() {
	test07();
	system("pause");
	return 0;
}

4.6.5继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

1. 访问子类同名成员，直接访问即可
2. 访问父类同名成员 需要加作用域

#include <iostream>
#include <string>
using namespace  std;

class Base3 {
public:
	void func() {
		cout<<"这是一个Base基类。" << endl;
	}
	void func(int) {
		cout << "这是另外一个Base基类。" << endl;
	}
	int m_Age=50;
};
class Son5 : public Base3 {
public :
	void func() {
		cout << "这是一个Son5子类。" << endl;
	}
	int m_Age = 26;
};
void Test05() {
	Son5 s5;
	cout << "Son5下的年龄：" <<s5.m_Age<< endl;
	cout << "Base下的年龄：" <<s5.Base3::m_Age<< endl;
	s5.func();
	s5.Base3::func();
	s5.Base3::func(10);
}
int main() {
	Test05();
	system("pause");
	return 0;
}

当子类与父类拥有同名的成员函数时，子类会隐藏父类中所有版本的同名成员函数

如果像范根父类中被隐藏的同名成员函数，需要加父类的作用域。

当子类与父类拥有同名的成员函数时，子类会隐藏父类中同名的成员函数，加作用域可以访问到父类中同名函数。

4.6.6继承同名静态成员处理方式

问题：继承中同名的静态成员再子类随想上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

1. 访问子类同名成员 直接访问即可。
2. 访问父类同名成员 需要加作用域。

#include <iostream>
#include <string>
using namespace  std;

//继承中的同名静态成员处理方式。
class Base 
{
public:
	static int m_A;//静态成员所有对象共享同一份数据：类内声明，类外初始化
	static void func() 
	{
		cout << "Base - static void func() " << endl;
	}
	static void func(int)
	{
		cout << "Base - 有参static void func() " << endl;
	}
};
int Base::m_A = 100;

class SON2:public Base {
public:
	static int m_A;
	static void func()
	{
		cout << "SON2 - static void func() " << endl;
	}
};
int SON2::m_A = 200;

void Test06() {
	//1.通过对象访问
	cout << "通过对象访问静态成员变量：" << endl;
	SON2 s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;
	//2.通过类名访问
	cout << "通过类名访问静态成员变量：" << endl;
	cout << "Son  下 m_A = " << SON2::m_A << endl;
	//第一个：：代表通过类名的方式进行访问，第二个：：代表访问父类作用域下的
	cout << "Base 下 m_A = " << SON2::Base::m_A << endl;
}
void Test07() {
	//1.通过对象访问
	cout << "通过对象访问静态成员函数：" << endl;
	SON2 S2;
	S2.func();
	S2.Base::func();
	//2.通过类名的方式访问
	cout << "通过类名访问静态成员函数：" << endl;
	SON2::func();
	SON2::Base::func();
	//子类出现和父类同名的静态成员函数，也会隐藏父类中所有同名成员函数
	//如果想访问父类中被隐藏的同名成员，需要加作用域
	SON2::Base::func(10);
	
}
int main() {
	//Test06();
	Test07();
	system("pause");
	return 0;
}

4.6.7多继承语法

C++允许一个类继承多个类

语法：class 子类：继承方式 父类1，继承方式 父类2，…

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承。

#include <iostream>
#include <string>
using namespace std;

class BBase1 {
public:
	BBase1() {
		m_A = 100;
	}
	int m_A;
};
class BBase2 {
public:
	BBase2() {
		m_A = 200;
	}
	int m_A;
};
class Son :public BBase1, public BBase2 {
public:
	Son() {
		int m_C = 300;
		int m_D = 400;
	}
	int m_C ;
	int m_D ;
};
void Test08() {
	Son s;
	cout << "size of Son " <<sizeof(s) <<endl;
	//当父类中出现同名成员时，需要加作用域区分
	cout << "BBase1::m_A = " << s.BBase1::m_A << endl;
	cout << "BBase2::m_A = " << s.BBase2::m_A << endl;
}
int main() {
	Test08();
	system("pause");
	return 0;
}

4.6.8 菱形（钻石）继承

菱形继承的概念:

​ 两个派生类继承同一个基类

​ 又有某个类同时继承着两个派生类

​ 这种继承被称之为菱形继承，或者钻石继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C9MsBjqX-1685672196903)(F:\Desktop\C++\fig\微信图片_20230421181259.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0nB9uOE2-1685672196904)(F:\Desktop\C++\fig\微信图片_20230421181310.png)]

#include <iostream>
#include <string>
using namespace std;

class Animal {
public:
	int m_Age;
};
//利用虚继承  解决菱形继承的问题
// 在继承之前加上关键字 virtual 变为虚继承
// Animal类称之为  虚基类（其中最大的类称之为虚基类）
//羊类
class Sheep:virtual public Animal {

};
//驼类
class Tuo :virtual public Animal {

};
//羊驼类
class TuoSheep :public Sheep, public Tuo {

};
void TEST01() {
	TuoSheep ts;
	ts.Sheep::m_Age = 18;
	ts.Tuo::m_Age = 28;
	//当菱形继承时，两个父类拥有相同数据，需要加以作用域区分
	cout << "ts.Sheep::m_Age = "<<ts.Sheep::m_Age << endl;
	cout << "ts.Tuo::m_Age = " << ts.Tuo::m_Age << endl;
	cout << "ts.m_Age = " << ts.m_Age << endl;
	//这份数据我们知道  只要有一份就可以了，菱形继承导致数据有两份，资源会造成浪费。

}
int main() {
	TEST01();
	system("pause");
	return 0;
}

4.7 多态

4.7.1 多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类

1. 静态多态：函数重载和运算符重载属于静态多态，复用函数名
2. 动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态的区别：

1. 静态多态的函数地址早绑定 - 编译阶段确定函数地址
2. 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

#include <iostream>
#include <string>
using namespace std;

//多态


//动物类
class Animal 
{
public:
    //虚函数
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};
class Cat:public Animal{
public:
	//函数重写   函数返回值的类型  函数名称   参数列表完全相同，因此重写speak函数，下边speak函数前的virtual可写也可不写
	void speak() {
		cout << "猫在说话" << endl;
	}
};
class Dog:public Animal {
public:
	void speak() {
		cout << "狗在说话" << endl;
	}
};
//执行说话的函数
//地址早绑定  在编译阶段确定函数地址（代码写完后就已经能看出来doSpeak函数是在调用Animal类）
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

//动态多态满足的条件
//1、 有继承关系
//2、 子类重写父类的虚函数

//动态多态使用
//父类的指针或者引用 指向子类对象
void doSpeak(Animal &animal)//Animal &animal = cat（由父类的引用来指向对象。）
{
	animal.speak();
}
void test01() {
	Cat cat;
	doSpeak(cat);
	cout << "***************************" << endl;
	Dog dog;
	doSpeak(dog);
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

多态满足的条件

1. 有继承关系
2. 子类重写父类中的虚函数

多态使用条件

1. 父类指针或引用指向子类对象

重写：函数返回值类型 函数名 参数列表 完全一致称之为重写

多态的底层原理：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZuhqAqOi-1685672196904)(F:\Desktop\C++\fig\微信图片_20230421211744.png)]

#include <iostream>
#include <string>
using namespace std;

//案例描述：
//分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

//多态的优点
//1. 代码组织结构清晰
//2.可读性强
//3.利用前期和后期的扩展以及维护

//普通写法实现计算器
class Calculator {
public:
	Calculator(double num1, double num2) { m_num1 = num1; m_num2 = num2; }
	double getResult(string oper) {
		if (oper == "+") {
			return m_num1 + m_num2;
		}
		else if (oper == "-") {
			return m_num1 - m_num2;
		}
		else if (oper == "*") {
			return m_num1 * m_num2;
		}
		//如果想扩展新的功能，需要修改源码，
		//在真实的开发中  提倡的四  开闭原则
		//开闭原则：对扩展进行开发，对修改进行关闭
	}
	double m_num1;//操作数1
	double m_num2;//操作数2
};
void test03() {
	Calculator c(10,10);
	cout << c.m_num1 << "+" << c.m_num2 << "=" << c.getResult("+") << endl;
	cout << c.m_num1 << "-" << c.m_num2 << "=" << c.getResult("-") << endl;
	cout << c.m_num1 << "*" << c.m_num2 << "=" << c.getResult("*") << endl;
}

//利用多态实现计算器

//实现计算器抽象类

class AbstractCalaulator {
public:
	virtual int GetResult() {
		return 0;
	}
	int m_num1;
	int m_num2;
};
class AddCalaulator:public AbstractCalaulator {
public:
	int GetResult() {
		return m_num1 + m_num2;
	}
};
class SubCalaulator:public AbstractCalaulator {
public:
	int GetResult() {
		return m_num1 - m_num2;
	}
};
class MulCalaulator:public AbstractCalaulator {
public:
	int GetResult() {
		return m_num1 * m_num2;
	}
};
void test04() {
	//多态使用条件
	//父类指针或者引用指向子类对象


	//加法运算
	AbstractCalaulator * abc = new AddCalaulator;
	//AddCalaulator add;
	//add.m_num1 = 10;
	//add.m_num2 = 10;
	//cout<< add.m_num1 << " + " << add.m_num2 << " = " << add.GetResult() << endl;
	abc->m_num1 = 10;
	abc->m_num2 = 10;
	cout << abc->m_num1 << " + " << abc->m_num2 << " = " << abc->GetResult() << endl; //刚才用指针发现返回的是乱码的原因：是因为在子类中写了和父类一样的变量，导致不知道该怎么调用。

	//因为这个计算器是new出来的数据放在堆区，因此需要进行销毁
	delete abc;//注意这里的销毁是指的销毁掉数据了，并没有将指针类型进行销毁。
	abc = new SubCalaulator;
	abc->m_num1 = 10;
	abc->m_num2 = 10;
	cout << abc->m_num1 << " - " << abc->m_num2 << " = " << abc->GetResult() << endl;
	delete abc;//注意这里的销毁是指的销毁掉数据了，并没有将指针类型进行销毁。
	abc = new MulCalaulator;
	abc->m_num1 = 10;
	abc->m_num2 = 10;
	cout << abc->m_num1 << " * " << abc->m_num2 << " = " << abc->GetResult() << endl;


}
int main() {
	//test03(); 
	test04();
	system("pause");
	return 0;
}

4.7.3 纯虚函数和抽象函数

在多态中，通常父类中虚函数的实现是毫无意义的，主要是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：

virtual  返回值类型  函数名   （参数列表） = 0；

当类中有了纯虚函数，这个类也称之为抽象类

抽象类的特点：

1. 无法实例化对象
2. 子类必须重写抽象类中的纯虚函数，否则也属于抽象类。

#include <iostream>
#include <string>
using namespace std;

class Base {
public:
	virtual void func() = 0;
};


class Son:public Base {
public:
	void func() {
		cout << "这是一个抽象类函数func的重写" << endl;
	}
};
void test07() {
	Base* base = new Son;
	base->func();
	delete base;
}
int main() {
	test07();
	system("pause");
	return 0;
}

4.7.4 多态案例2 -制作饮品

制作饮品的流程大致为：煮水——冲泡——倒入杯中——加入辅料

利用多态技术实现本案例，提供首相制作饮品基类，提供子类制作咖啡和苦茶。

#include <iostream>
#include <string>
using namespace std;

class AbstractDrink {
public:
	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourIntoCup() = 0;
	//加入辅料
	virtual void Addsomething() = 0;
	void makeDrink() {
		Boil();
		Brew();
		PourIntoCup();
		Addsomething();
	}
};
//制作咖啡
class Coffe :public AbstractDrink {
public:
	//煮水
	void Boil() {
		cout << "煮矿泉水" << endl;
	};
	//冲泡
	void Brew() {
		cout << "冲泡" << endl;
	};
	//倒入杯中
	void PourIntoCup() {
		cout << "导入杯中" << endl;
	};
	//加入辅料
	void Addsomething() {
		cout << "添加糖和牛奶" << endl;
	};
};
//制作苦茶
class Tea :public AbstractDrink {
public:
	//煮水
	void Boil() {
		cout << "煮农夫山泉水" << endl;
	};
	//冲泡
	void Brew() {
		cout << "冲泡茶叶" << endl;
	};
	//倒入杯中
	void PourIntoCup() {
		cout << "导入杯中" << endl;
	};
	//加入辅料
	void Addsomething() {
		cout << "添加枸杞" << endl;
	};
};

void test08() {
	// 指针实现  
	AbstractDrink* ad = new Coffe;
	ad->makeDrink();
	delete ad;
	cout << "*******************制作茶叶****************" << endl;
	ad = new Tea;
	ad->makeDrink();
	delete ad;
}
int main() {
	//test07();
	test08();
	system("pause");
	return 0;
}

4.7.5 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构的共性：

1. 可以解决父类指针释放子类对象
2. 都需要有具体的函数实现

虚析构和纯虚析构区别：

如果时纯虚析构，该类属于抽象类，无法实例化对象

虚构析构语法：

virtual ~类名（）{}

纯虚构析构语法：

virtual ~类名（）= 0；

#include <iostream>
#include <string>
using namespace std;

//虚析构和纯虚析构（解决子类中析构代码调不到的问题）

class Animal1 {
public:
	
	Animal1() { cout << "Animal的构造函数调用！" << endl; }
	//纯虚函数
	virtual void speak() = 0;
	//利用虚析构可以解决 父类指针释放对象不干净的问题
	//virtual ~Animal1() { cout << "Ainmal的析构函数调用！" << endl; }
	
	//纯虚析构  需要声明也需要实现。
	//有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
	virtual ~Animal1() = 0;

};
Animal1::~Animal1() {
	cout << "Ainmal的纯虚析构函数调用！" << endl;
}
class Cat1 :public Animal1 {
public:
	Cat1(string name)
	{
		cout << "Cat的构造函数调用" << endl;
		m_name = new string(name); 
	}
	void speak() {
		cout << *m_name <<"小猫在说话" << endl;
	}
	~Cat1() {
		if (m_name != NULL) {
			cout << "Cat 的析构函数调用！" << endl;
			delete m_name;
			m_name = NULL;
		}
	}
	string *m_name;

};
void test09() {
	Animal1* am = new Cat1("Tom");
	am->speak();
	//父类指针在析构的时候  不会调用子类中的析构函数，导致子类如果有堆区属性，出现内存泄露现象。  解决方法：是将父类析构函数变为虚析构函数
	delete am;
}
int main() {
	//test08();
	test09();
	system("pause");
	return 0;
}

总结：

1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据，可以不写虚析构和纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类，无法实例化对象。

4.7.6 多态案例三-电脑组装

案例描述：

电脑主要组成部件为CPU(用于计算)，显卡（用于显示），内存条（用于存储）

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WyoRi5P8-1685672196905)(F:\Desktop\C++\fig\微信图片_20230422114132.png)]

#include <iostream>
#include <string>
using namespace std;

//电脑组装
//CPU类
class CPU {
public:
	virtual void calculate() = 0;
};
//显卡类
class VideoCard {
public:
	virtual void display() = 0;
};
//内存条类
class Memory {
public:
	virtual void storge() = 0;
};
//电脑类
class Computer {
public:
	Computer(CPU* cpu, VideoCard* vc, Memory* mem) {
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}
	void work() {
		//让零件工作起来
		m_cpu->calculate();
		m_vc->display();
		m_mem->storge();
	}
	~Computer() {
		if (m_cpu != NULL) {
			delete m_cpu;
			m_cpu = NULL;
		}
		if (m_vc != NULL) {
			delete m_vc;
			m_vc = NULL;
		}
		if (m_mem != NULL) {
			delete m_mem;
			m_mem = NULL;
		}
	}
private:
	CPU* m_cpu;  //CPU指针
	VideoCard * m_vc; //显卡指针
	Memory* m_mem;//内存指针

};
//具体的厂商
class IntelCPU :public CPU {
public:
	virtual void calculate() {
		cout<<"Intel的CPU开始计算了！" << endl;
	}
};
class IntelVideoCard :public VideoCard {
public:
	virtual void display() {
		cout << "Intel的显卡开始显示了！" << endl;
	}
};
class IntelMemory :public Memory {
public:
	virtual void storge() {
		cout << "Intel的内存开始存储了！" << endl;
	}
};

class LenoCPU :public CPU {
public:
	virtual void calculate() {
		cout << "Leno的CPU开始计算了！" << endl;
	}
};
class LenoVideoCard :public VideoCard {
public:
	virtual void display() {
		cout << "Leno的显卡开始显示了！" << endl;
	}
};
class LenoMemory :public Memory {
public:
	virtual void storge() {
		cout << "Leno的内存开始存储了！" << endl;
	}
};

void test10() {
	//第一台电脑零件
	CPU* intelcpu = new IntelCPU;
	VideoCard* intelvc = new IntelVideoCard;
	Memory* intelmem = new IntelMemory;

	//创建第一台电脑
	Computer* computer1 = new Computer(intelcpu, intelvc, intelmem);
	computer1->work();
	//释放堆区数据，一种方法是直接将所有堆区创建的数据都使用delete关键字直接进行删除，另一种方法是在Computer的析构函数释放零件。
	delete computer1;
	cout << "*****************************************************" << endl;
	Computer* computer2 = new Computer(new LenoCPU, new LenoVideoCard, new LenoMemory);
	computer2->work();
	//释放堆区数据，一种方法是直接将所有堆区创建的数据都使用delete关键字直接进行删除，另一种方法是在Computer的析构函数释放零件。
	delete computer2;
	cout << "*****************************************************" << endl;
	Computer* computer3 = new Computer(new LenoCPU, new IntelVideoCard, new LenoMemory);
	computer3->work();
	//释放堆区数据，一种方法是直接将所有堆区创建的数据都使用delete关键字直接进行删除，另一种方法是在Computer的析构函数释放零件。
	delete computer3;
}
int main() {
	//test09();
	test10();
	system("pause");
	return 0;
}

5.文件操作

程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放。通过文件可以将数据持久化

C++中对文件操作需要包含头文件 文件流

文件类型分为两种：

1. 文本文件 -文件以文本的ASCII码的形式存储在计算机中
2. 二进制文件 -文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们。

操作文件的三大类：

1. ofstream : 写操作
2. ifstream : 读操作
3. fstream : 读写操作

5.1 文本文件

5.1.1写文件

写文件步骤如下：

1.包含头文件

#include

2.创建流对象

ofstream ofs;

3.打开文件

ofs.open(“文件路径”，打开方式)

4.写数据

ofs<<“写入的数据”；//往文件中输出

5.关闭文件

ofs.close();

#include <iostream>
#include <string>
#include <fstream>  //关于文本文件的头文件包含。
using namespace std;

//文本文件 写文件

void test01() {
//1.包含头文件  fstream

//2.创建流对象

	ofstream ofs;
//3.指定打开方式
	ofs.open("test.txt", ios::out);

//4.写内容
	ofs << "name: Kang Zhao" << endl;
	ofs << "sex: Men" << endl;
	ofs << "age: 18" << endl;

//5.文件关闭
	ofs.close();
}

int main() {
	test01();
	system("pause");
	return 0;
}

总结：

1. 文件操作必须包含头文件fstream;
2. 读文件可以利用ofstream,或者fstream类
3. 打开文件时候需要指定操作文件的路径，以及打开方式
4. 利用<<可以向文件中写数据
5. 操作完毕，要关闭文件。

5.1.2 读文件

读文件与写文件步骤相似，但是读取方式相对比较多。

读取文件的步骤如下:

1.包含头文件

#include

2.创建对象流

ifstream ifs;

3.打开文件并判断文件是否打开成功

ifs.open(“文件路径”，打开方式)

4.读取数据

四种方式读取

5.关闭文件

ifs.close()

#include <iostream>
#include <string>
#include <fstream>  //关于文本文件的头文件包含。
using namespace std;

//文本文件的读取
void test02() {
	//1.包含头文件

	//2.创建流对象
	ifstream ifs;
	//3.打开文件，并且判断是否打开成功
	ifs.open("test.txt", ios::in);
	
	if (!ifs.is_open())
	{
		cout << "文件打开失败" << endl;
		return;
	}
	//4.读数据
	
	//第一种读取数据的方式
	//char buf[1024] = { 0 };
	//while (ifs >> buf) {
	//	cout << buf << endl;
	//}
	第二种读取数据的方式
	//char buf[1024] = { 0 };
	//while (ifs.getline(buf, sizeof(buf))) {
	//	cout << buf << endl;
	//}
	第三种方式
	//string buf;
	//while (getline(ifs, buf)) {
	//	cout << buf << endl;
	//}
	//第四种
	char c;
	while ((c = ifs.get()) != EOF)//EOF end of file
	{
		cout << c;
	}
	//5.关闭文件
	ifs.close();
}

int main() {
	test02();
	system("pause");
	return 0;
}

5.2二进制文件

以二进制的方式对文件进行读写操作

打开方式要指定为 ios::binary

5.2.1 写文件

二进制方式写文件主要利用流对象调用成员函数write

函数原型：ostream& write(const char * buffer,int len);

参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数。

#include <iostream>
//#include <string>
#include <fstream>  //关于文本文件的头文件包含。
using namespace std;

//二进制文件  写文件
class Person {
public:
	char m_Name[64]; //姓名   //在对文件进行操作时，最好还是使用C语言的字符串，因为底层函数是C写的。
	int m_Age; // 年龄

};

void test03() {
	//1.包含头文件
	
	//2.创建流对象
	ofstream ofs;
	//3.打开文件
	ofs.open("person.txt", ios::out | ios::binary);
	//4.写文件
	Person p = { "张三",18 };
	ofs.write((const char*)&p, sizeof(Person));
	//5.关闭文件
	ofs.close();

}

int main() {
	test03();
	system("pause");
	return 0;
}

二进制方式 读文件

#include <iostream>
//#include <string>
#include <fstream>  //关于文本文件的头文件包含。
using namespace std;

//二进制文件  读文件
class Person {
public:
	char m_name[64];
	int m_age;
};

void test04() {
	//1.包含头文件

	//2.创建流对象
	ifstream ifs;
	//3.打开文件  判断文件是否打开成功
	ifs.open("person.txt", ios::in | ios::binary);

	if (!ifs.is_open()) {
		cout << "文件打开失败" << endl;
		return;
	}
	//4.读文件
	Person p;

	ifs.read((char*)&p, sizeof(Person));

	cout << "姓名：" << p.m_name << " 年龄：" <<p.m_age <<endl;
	//5.关闭文件
	ifs.close();
}

int main() {
	test04();
	system("pause");
	return 0;
}

c++核心编程

主要学习面向对象编程技术。

1.内存分区模型

C++在执行时，将内存大方向分为4个区域。

1. 代码区：存放函数体的二进制代码，由操作系统进行管理的。
2. 全局区：存放全局变量和静态变量以及常量
3. 栈区：由编译器自动分配释放、存放函数的参数值，局部变量等。
4. 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

内存四区的意义：不同区域存放的数据，赋予不同的声明周期，给我们更大的灵活编程。

1.1代码区

在程序编译后，生成了exe的可执行程序，未执行该程序前分为两个区域。

代码区:

​ 存放CPU执行的机器指令。

​ 代码区时共享的，共享的目的时对于频繁执行的程序，只需要在内存中有一份代码即可。

​ 代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令。

全局区：（全局变量、静态变量、常量）

​ 全局变量和静态变量存放在此

​ 全局区还包含了常量区，字符串常量和其他常量野存在此。

​ 该区域的数据在程序结束后由操作系统释放。

程序运行前是有代码区和全局区的，程序运行后才有栈区和堆区。

函数体内部的变量是局部变量，在函数体外边是全局变量。在普通变量前面加上static，属于静态变量。

//常量

//字符串常量，

cout<<“字符串常量的地址为：”<<(int)&“hello world”<<endl;

//const修饰的常量。

const修饰的全局变量和const修饰的局部变量

局部变量、const修饰的局部变量（局部常量）不在全局区中、

全局变量、静态变量（static关键字）、常量中的字符串常量和consr修饰的全局变量（全局常量）在全局区中。

程序运行后的区域

1.3 栈区：

由编译器管理开辟和释放，注意事项——>不要返回局部变量的地址。

栈区存放两种类型的参数：一种是局部变量，一种是形参数据。

1.4堆区：

由程序员分配数据，若程序员不释放，程序结束时由操作系统进行收回。

在C++中主要利用new在堆区开辟内存。

1.5 new操作符

C++中利用new操作符在堆区中开辟数据

堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete.

语法： new 数据类型

利用new创建的数据，会返回该数据对应的类型指针。

2.引用

2.1引用的基本使用

作用：给变量起一个别名

语法：数据类型 &别名 = 原名

2.2注意事项

1. 引用必须初始化 int &b=a;
2. 引用在初始化后，不可以改变。

2.3引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修饰实参

#include <iostream>
#include <string>
#include <ctime>
using namespace std;


//交换函数
void mySwap01(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}
void mySwap02(int* a, int* b) {
	int temp =  *a;
	*a = *b;
	*b = temp;
}
void mySwap03(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}


int main() {
	//引用的基本语法
	//数据类型 &别名 = 原名
	int a = 10;
	int c = 20;
	int &b = a;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	b = 100;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	system("pause");
	cout << "****************************" << endl;
	//mySwap01(a, c);//值传递不改变实参值。形参不会修饰实参
	mySwap02(&a, &c);//地址传递改变实参值。形参会修饰实参
	//mySwap03(a, c);//引用传递，形参会修饰实参的。
	cout << "a=" << a << endl;
	cout << "c=" << c << endl;
	
	return 0;
}

总结：通过引用参数产生的效果同按地址传递是一样的，引用的语法更清楚简单。

2.4引用做函数的返回值

作用：引用是可以作为函数的返回值存在的。

注意：不要返回局部变量引用。

用法：函数调用作为

#include <iostream>
#include <string>
#include <ctime>
using namespace std;

//引用做函数的返回值
//1.不要返回局部变量的引用
int& test01() {
	int a = 10;//局部变量存放在四区中的  栈区中
	return a;
}
//2.函数的调用可以作为左值？
int& test02()
{
	static int a = 10;//静态变量，存放在全局区，全局区的数据在程序结束后系统释放。
	return a;
}
int main() {
	int& ref = test01();
	cout << "ref = " << ref << endl;//第一次结果正确，是因为编译器做了保留
	cout << "ref = " << ref << endl;//第二次结果错误，是因为a的内存已经释放。
	int& ref2 = test02();
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;
	test02() = 1000;//如果函数的返回值是引用，这个函数调用可以作为左值
	cout << "ref2 = " << ref2 << endl;
	cout << "ref2 = " << ref2 << endl;
	system("pause");
	return 0;
}

2.5引用的本质在C++内部实现是一个指针常量。

结论：C++推荐引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了。

3.函数提高

3.1函数默认参数

在C++中，函数的形参列表中的形参是可以有默认值的。

语法：返回值类型 函数名 （参数 = 默认值）{}

#include <iostream>
#include <string>
#include<math.h>
using namespace std;
//如果我们自己传入数据，就用自己的数据，如果没有，那么就用默认值
//语法： 返回值类型  函数名 （形参 = 默认值）{}
int func(int a, int b=20, int c=20) {
	return a + b + c;
}
int func2(int a, int b, int c = 12) {
	return a + b + c;
}

//1.注意事项
//1.如果某个位置已经有了默认参数，那么从这个位置往后，从做往右就必须都有默认值
//2.如果函数的声明有了默认参数，则函数的实现就不能有默认参数了,当声明和实现中都有参数时就会产生二义性。出现错误
int func3(int a=10, int b=10);
int func3(int a, int b) {
	return a + b;
}

int main07() {
	func3(10, 10);
	cout << func(10) << endl;
	system("pause");
	return 0;
}

3.2 函数的占位参数

#include <iostream>
#include <string>
#include <math.h>
using namespace std;

//占位参数
//返回值类型 函数名（数据类型）{}

//目前阶段的占位参数  我们还用不到，后面课程中会用到
//占位参数  还可以有默认参数值。下边函数中的第二个int为占位参数，可以有默认值。
void func(int a,int = 10){
	cout << "this is func" << endl;
}
int main() {

	system("pause");
	return 0;
}

3.3函数重载

作用： 函数名可以相同，提高复用性

函数重载满足条件：

1. 同一个作用域下
2. 函数名称相同
3. 函数参数类型不同 或者个数不同或者顺序不同

注意函数的返回值不可以作为函数重载的条件

#include <iostream>
#include <string>
using namespace std;
//函数重载
//可以让函数名相同，提高复用性

//函数重载必须满足的条件
//1.必须在同一个作用域下（同一个局部域，或者全局域）
//2.函数名相同
//3.函数类型不同，或者个数不同，或者顺序不同
//注意函数的返回值不可以作为函数重载的条件
void func() {
	cout << "func的函数调用" << endl;
}
void func(int a) {
	cout << "func(int a)的函数调用" << endl;
}
void func(int a,float b) {
	cout << "func(int a,float b)的函数调用" << endl;
}
void func(float b,int a) {
	cout << "func(float b,int a)的函数调用" << endl;
}
int main() {
	func();
	func(5);
	func(5,3.1);
	func(2.1,5);
	system("pause");
	return 0;
}

3.3.2 函数重载的注意事项

1.引用作为函数重载条件

2.函数重载碰到函数默认参数

#include <iostream>
#include <string>
using namespace std;
//函数重载
//可以让函数名相同，提高复用性

//函数重载必须满足的条件
//1.必须在同一个作用域下（同一个局部域，或者全局域）
//2.函数名相同
//3.函数类型不同，或者个数不同，或者顺序不同
//注意函数的返回值不可以作为函数重载的条件
void func() {
	cout << "func的函数调用" << endl;
}
void func(int a) {
	cout << "func(int a)的函数调用" << endl;
}
void func(int a,float b) {
	cout << "func(int a,float b)的函数调用" << endl;
}
void func(float b,int a) {
	cout << "func(float b,int a)的函数调用" << endl;
}
//函数重载的注意事项
//1.引用作为重载的条件
void fun(int& a) // int &a = 10; 不合法
{
	cout << "fun(int& a)的函数调用" << endl;
}

void fun(const int& a) //const int &a = 10; 合法的，因为系统默认会创建一个临时变量temp = 10来进行引用操作
{
	cout << "fun(const int& a)的函数调用" << endl; //加了const是只读状态
}

//2.函数重载碰到默认参数
void fun2(int a,int b= 10) {
	cout << "fun2(int a,int b= 10)的函数调用" << endl;
}

void fun2(int a) {
	cout << "fun2(int a)的函数调用" << endl;
}
int main() {
	func();
	func(5);
	func(5,3.1);
	func(2.1,5);
	int a = 100;
	fun(a);//调用函数fun(int &a)
	fun(100);//调用函数fun(const int &a)
	//fun2(10); 通过不了，原因是因为产生了二义性
	fun2(10, 20);
	system("pause");
	return 0;
}

4 类和对象

C++面向对象的三大特性为：封装、继承、多态

C++认为万事万物都皆为对象，对象上有其属性和行为

例如：

​ 人可以作为对象，属性有名字、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌。。。。。

​ 车可以作为对象，属性有轮胎、方向盘、车灯…行为有载人、放音乐、放空调…

​ 具有相同性质的对象，我们可以抽象为类，人属于人类，车属于车类。

4.1封装

4.1.1封装的意义

封装是C++面向对象的三大特性之一

封装的意义：

1. 将属性和行为作为一个整体，表现生活事务
2. 将属性和行为加以权限控制

封装意义一：

​ 在设计类的时候，属性和行为写在一起，表现十五

语法：class 类名{访问权限：属性/行为}；

实例1：设计一个圆类，球圆的周长。

实例2：设计一个学生类使其能够给学生的姓名和学号进行赋值，能够展示学生的姓名和学号

#include <iostream>
#include <string>
#include <ctime>
using namespace std;
//学生类
class Student {
public:	//公共权限
	//类中的属性和成员统一称之为成员
	//属性   成员属性   成员变量   
	//行为   成员函数   成员方法
	string name;
	string stu_id;
	//给学生姓名和学号赋值
	void Assignment(string Name,string id)
	{
		name = Name;
		stu_id = id;
	}
	//显示学生的姓名和学号
	void showInfo() {
		cout << "姓名：" << name 
		 << "\t学号：" << stu_id << endl;
	}
};
int main() {
	//创建一个具体的学生  实例化对象
	Student s1;
	Student s2;
	//给s1对象，进行属性赋值操作(在main()函数内部实现的)
	//需要调用方法实现的
	s2.Assignment("李四", "20171212555");
	s1.name = "张三";
	s1.stu_id = "20161024112";
	s1.showInfo();
	s2.showInfo();
	system("pause");
	return 0;
}

封装的意义二：

类在设计时，可以把属性和行为放在不同权限下，加以控制

访问权限有三种：

1.public 公共权限 类内和类外都可以访问

2.protected 保护权限 类内可以访问，类外不能访问

3.private 私有权限 类内可以访问，类外不能访问

#include <iostream>
#include <string>
#include <ctime>
using namespace std;

/*1.public    公共权限			类内和类外都可以访问
  2.protected  保护权限		    类内可以访问，类外不能访问(在继承中能够体现，儿子可以访问父亲的东西)
  3.private    私有权限		    类内可以访问，类外不能访问（儿子不能访问父亲的私有变量）
*/
class Person {
	//公共权限的成员
public:
	string m_name;
protected:
	string m_car;
private:
	string m_password;

public:
	void func() {
		m_name = "张三";
		m_car = "奥迪";
		m_password = "124532";

	}
};

int main() {
	Person p1;
	p1.m_name = "李四";
	//p1.m_car = "奔驰";  该变量是保护变量所以类外不可以访问
	//p1.m_password = 201245;  该变量是私有变量类外不能访问
	system("pause");
	return 0;
}

4.1.2struct和class的区别

在C++中struct和class的唯一区别在于，默认的访问权限是不同的

区别：

​ struct 默认权限是公共的。

​ class 默认权限是私有的。

4.1.3成员属性私有化

优点1： 将所有成员属性设置为私有，可以自己控制读写权限。

优点2：对于写权限，我么可以检测数据的有效性。

案例：设计立方体类

​ 求出立方体的面积和体积

​ 分别用全局函数和成员函数判断两个立方体是否相等。

#include <iostream>
#include <string>
using namespace std;
//设计立方体类进行计算体积和面积
// S表面积 = 6*（ab+ac+bc）; 
//V = 底面积S * 高h;
class Cube {
private:
	double m_L;
	double m_H;
	double m_W;
	//计算体积
public:
	//设置长宽高
	void setAttibute(double L, double H, double W)
	{
		m_L = L;
		m_H = H;
		m_W = W;
	}
	double getAttibute() {

		return m_L, m_H, m_W;
	}
	double Volu(){
		return m_H * m_L * m_W;
	}
	//计算表面积
	double Surf() {
		return 2 * (m_H * m_L + m_H * m_W + m_L * m_W);
	}
	//利用成员函数来进行判断两个立方体是否相同。
	bool isSameByClass(Cube& c) //这里只需要传入一个立方体参数就行，因为在类内来进行判断是否相等的话，它自身就有一个立方体
	{
		if (getAttibute() == c.getAttibute()) {
			return  true;
		}
		return false;
	}
};
//利用全局函数来判断两个立方体是否相等(通过引用的传递不会再复制出一份数据)
bool isSame(Cube& c1, Cube& c2) {
	if (c1.getAttibute() == c2.getAttibute()) {
		return  true;
	}
	return false;
}

int main() {
	Cube c1;
	Cube c2;
	//c1.m_H = 3.10;
	//c1.m_L = 2.8;
	//c1.m_W = 2.2;
	c1.setAttibute(3.10, 2.8, 2.2);
	cout << "立方体体积为:" << c1.Volu() << endl;
	cout << "立方体的面积为："<<c1.Surf()<<endl;
	cout << "********************全局函数判断**************************" << endl;
	c2.setAttibute(3.10, 2.8, 2.2);
	if (isSame(c1, c2) == true) {

		cout << "两个立方体是相同的。" << endl;
	}
	else { cout << "两个立方体是不同的。" << endl; }
	cout << "********************成员函数判断**************************" << endl;
	if (c1.isSameByClass(c2) == true) {
		cout << "两个立方体是相同的。" << endl;
	}
	else { cout << "两个立方体是不同的。" << endl; }
	system("pause");
	return 0;
}

案例2.点和圆的关系

设计一个圆形类和一个点内，计算点和圆的关系。

#include <iostream>
#include <string>
using namespace std;
//点和圆的关系案例
//点类
class Point {
public:
	//设置x
	void setX(double xx) {
		x = xx;
	}
	//获取x
	double getX() {
		return x;
	}
	//设置y
	void setY(double yy) {
	y = yy;
}
	//获取y
	double getY() {
		return y;
	}
private:
	double x;
	double y;
	//设置x
};
//圆类
class Circle {
public:
	//设置半径
	void setR(double r) {
		R = r;
	}
	//获取半径
	double getR() {
		return R;
	}
	//设置圆心
	void setcenter(Point center) {
		circlecenter = center;
	}
	//获取圆心
	Point getcenter() {
		return circlecenter;
	}
private:
	double R;
//在类中可以让另一个类，作为本类成员存在
	Point circlecenter;
};
//写一个全局函数用来计算距离并判断点和圆的函数关系
void pointAndCircleRelation(Circle& c, Point& p) {
//先计算距离的平方
	double pointDistance = (c.getcenter().getX() - p.getX()) * (c.getcenter().getX() - p.getX()) + (c.getcenter().getY() - p.getY()) * (c.getcenter().getY() - p.getY());
//然后计算半径的平方
	double Rsquare = c.getR() * c.getR();
//进行判断点和圆的位置关系
	if (pointDistance == Rsquare) {
		cout << "点在圆上" << endl;
	}
	else if (pointDistance > Rsquare) { cout << "点在圆外" << endl; }
	else { cout << "点在圆内" << endl; }
}
int main() {
	//创建一个圆
	Circle c1;
	c1.setR(10);
	Point center;
	center.setX(10);
	center.setY(10);
	c1.setcenter(center);
	//创建一个点
	Point p1;
	p1.setX(10);
	p1.setY(20);
	pointAndCircleRelation(c1, p1);
	//判断点和圆的位置关系
	system("pause");
	return 0;
}
//大型开发把所有的类写进一个类中是不好的，不可以的。都写在一个文件中会使得代码量太大了。

在大型开发把所有的类写进一个类中是不好的，不可以的。都写在一个文件中会使得代码量太大了。因此需要分文件编写，将点类和圆类分文件编写，现在头文件中进行声明函数，然后再创建相应的cpp文件实现上述声明的函数，最后在程序中调用。

e.g.先创建一个头文件包含point类

#pragma once  //防止头文件重复包含
#include <iostream>
using namespace std;

//留住函数的声明和变量的声明，不需要实现
class Point {
public:
	//设置x
	void setX(double xx);
	//获取x
	double getX();
	//设置y
	void setY(double yy);
	//获取y
	double getY();
private:
	double x;
	double y;
	//设置x
};

然后写出相应的.cpp文件实现上述的函数功能

#include "point.h"

//只需要留住所有函数的实现。
//设置x  在这些函数上加上Point的作用域，
void Point::setX(double xx) {
	x = xx;
}
//获取x
double Point::getX() {
	return x;
}
//设置y
void Point::setY(double yy) {
	y = yy;
}
//获取y
double Point::getY() {
	return y;
}

最后在函数主体部分包含头文件进行调用

#include <iostream>
#include <string>
using namespace std;
#include "circle.h"
#include "point.h"

//写一个全局函数用来计算距离并判断点和圆的函数关系
void pointAndCircleRelation(Circle& c, Point& p) {
//先计算距离的平方
	double pointDistance = (c.getcenter().getX() - p.getX()) * (c.getcenter().getX() - p.getX()) + (c.getcenter().getY() - p.getY()) * (c.getcenter().getY() - p.getY());
//然后计算半径的平方
	double Rsquare = c.getR() * c.getR();
//进行判断点和圆的位置关系
	if (pointDistance == Rsquare) {
		cout << "点在圆上" << endl;
	}
	else if (pointDistance > Rsquare) { cout << "点在圆外" << endl; }
	else { cout << "点在圆内" << endl; }
}
int main() {
	//创建一个圆
	Circle c1;
	c1.setR(10);
	Point center;
	center.setX(10);
	center.setY(10);
	c1.setcenter(center);
	//创建一个点
	Point p1;
	p1.setX(10);
	p1.setY(20);
	pointAndCircleRelation(c1, p1);
	//判断点和圆的位置关系
	system("pause");
	return 0;
}
//大型开发把所有的类写进一个类中是不好的，不可以的。都写在一个文件中会使得代码量太大了。

4.2对象的初始化和清理

1. 生活中我们买的电子产品基本都会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全。
2. C++中面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置

4.2.1构造函数（初始化）和析构函数（清理）

对象的初始化和清理也是两个非常重要的安全问题

	一个对象或者变量没有初始状态，对其使用后果是未知
	同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作对象的初始化和清理工作是编译强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。

​ 构造函数: 主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。

​ 析构函数: 主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法: 类名() {}
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次
析构函数语法: ~类名() {}
1.析构函数，没有返回值也不写void
2.函数名称与类名相同,在名称前加上符号 ~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

#include <iostream>
#include <string>
using namespace std;
class Person{
public:
	/*1.构造函数
	没有返回值，不需要写void
	函数名  与类的名字相同
	构造函数可以有参数，可以发生重载
	创建对象时，构造函数会自动调用，而且只调用一次。*/
	Person(){
	cout<<"这是一个构造函数。" << endl; }
	/*2.析构函数
	没有返回值  不写void
	函数名和类名相同 在名称前加~
	析构函数不可以有参数的，不可以发生重载
	对象在销毁前  会自动调用析构函数，而且只能调用一次。
	*/
	~Person() { cout << "这是一个析构函数。" << endl; }
};

//构造和析构函数都必须有实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构。
void test01()
{
	Person p;//局部变量，在栈上的数据，test01执行完毕后，释放这个对象。
}

int main(){

	//test01();

	Person p;//调用这个只会出现构造函数的调用，因为他在执行时是到整个main（）函数走完才执行的析构函数，因此是在最后调用析构函数。

	system("pause");
	return 0;
}

4.2.2构造函数的分类及调用

两种分类方式：

​ 按参数分为：有参构造和无参构造

​ 按类型分为：普通构造和拷贝构造

三种调用方式：

​ 括号法

​ 显示法

​ 隐式转换法

#include <iostream>
#include <string>
using namespace std;
class PPerson {
public:
	/*1.构造函数
	没有返回值，不需要写void
	函数名  与类的名字相同
	构造函数可以有参数，可以发生重载
	创建对象时，构造函数会自动调用，而且只调用一次。*/
	//无参构造函数（默认构造函数）
	int aage = 0;
	PPerson() {
		cout << "这是一个无参构造函数。" << endl;
	}
	//有参构造函数
	PPerson(int a) {
		aage = a;
		cout << "这是一个有参构造函数。" << endl;
	}
	//按类型分为普通构造函数和拷贝构造函数。
	//拷贝构造函数
	PPerson(const PPerson& p) {
		//将传入的人身上的属性拷贝过来。
		aage = p.aage;
		cout << "这是一个拷贝构造函数。" << endl;
	}
	/*2.析构函数
	没有返回值  不写void
	函数名和类名相同 在名称前加~
	析构函数不可以有参数的，不可以发生重载
	对象在销毁前  会自动调用析构函数，而且只能调用一次。
	*/
	~PPerson() { cout << "这是一个析构函数。" << endl; }
};

//构造和析构函数都必须有实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构。
//void Test01()
//{
//	PPerson p;//局部变量，在栈上的数据，test01执行完毕后，释放这个对象。
//}
//调用
void Test02() {
	//1.括号法
	//PPerson p2(10);//有参构造函数
	拷贝构造函数;
	//PPerson p3(p2); //拷贝构造函数的调用
	拷贝函数的用途
	注意事项1：在调用默认构造函数时，不要加（），因为当加上括号时，编译器会认为这是一个函数的声明，不会认为在创建对象。
	//cout << "p2的年龄为：" << p2.aage << endl;
	//cout << "p3的年龄为：" << p3.aage << endl;
	//2.显示法
	PPerson p1;
	PPerson p4 = PPerson(10);//有参构造
	PPerson p5 = PPerson(p4);//拷贝构造

	//PPerson(10);//匿名对象，特点：当前行执行结束后，系统会立即回收掉匿名对象。
	//cout << "aaaaa" << endl;

	//注意事项2
	//不要利用拷贝函数 初始化匿名对象  编译器会认为 PPerson (p5) = PPerson p5;  会认为是声明。
	//PPerson(p5);

	//3.隐式转换法。

	PPerson p6 = 10;//相当于是进行了一个隐式和显示的转换  PPerson p6 = PPerson(10);
	PPerson p7 = p6;//拷贝构造
}

int main() {

	//Test01();
	Test02();
	//PPerson p;//调用这个只会出现构造函数的调用，因为他在执行时是到整个main（）函数走完才执行的析构函数，因此是在最后调用析构函数。

	system("pause");
	return 0;
}

4.2.3拷贝构造函数的调用时机

1. 使用一个已经创建完毕的对象来初始化一个新的对象

2. 值传递的方式给函数参数传值
3. 以值方式返回局部对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nTvldx03-1685672196906)(F:\Desktop\C++\fig\5a27a4ce6815b985880c447ee92931e.png)]

#include <iostream>
#include <string>
using namespace std;

class Person {
public:
	int m_age=0;
	Person() {
		cout << "这是一个默认构造函数。" << endl;
	}
	Person(int a) {
		m_age = a;
		cout << "这是一个有参构造函数。" << endl;
	}
	Person(const Person& p) {
		cout << "这是一个拷贝构造函数。" << endl;
	}
	~Person() {
		cout << "这是一个析构函数" << endl;
	}
};

//1. 使用一个已经创建完毕的对象来初始化一个新的对象
void test01() {
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄为" <<p2.m_age<<endl;
}
//2. 值传递的方式给函数参数传值
void doWork(Person p) {

}

void test02() {
	Person p;
	doWork(p);//实参p传给形参的时候会调用拷贝构造函数。
}
//3. 以值方式返回局部对象
Person doWork2()
{
	Person p1;//
//	cout << (int*)&p1 << endl;
	return p1; //返回时，会根据p1创建出一个新的对象返回，并传入test03

}
void test03() {
	Person p = doWork2();
//	cout << (int*)&p << endl;
}
int main() {
	//test02();
	test03();
	system("pause");
	return 0;
}

4.2.4构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

1.默认构造函数（无参，函数体为空）

2.默认析构函数（无参，函数体为空）

3.默认拷贝构造函数。对属性进行值拷贝

函数调用规则如下：

1. 如果用户定义又参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造
2. 如果用户定义拷贝构造函数，C++不会再提供其他构造函数

4.2.5 深拷贝和浅拷贝

深浅拷贝时面试常问的问题，常见的一个坑。

浅拷贝：简单的赋值拷贝操作（编译器所作的是浅拷贝）

深拷贝：再堆区重新申请空间，进行拷贝操作。

浅拷贝带来的问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kii5c74a-1685672196906)(F:\Desktop\C++\fig\浅拷贝.png)]

相当于是在进行析构的时候同一块内存空间析构了两次。这一问题可以采用深拷贝完成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-diuTTym3-1685672196907)(F:\Desktop\C++\fig\微信图片_20230418194337.png)]

#include <iostream>
#include <string>
using namespace std;

class person {
public:
	int m_age = 0;
	int* m_Height;
	person() {
		cout << "这是一个默认构造函数。" << endl;
	}
	person(int a,int height) {
		m_age = a;
		m_Height =new int(height);//利用new关键字在堆区创建
		cout << "这是一个有参构造函数。" << endl;
	}
	//person(const person& p) {
	//	cout << "这是一个拷贝构造函数。" << endl;
	//}

	//自己实现拷贝构造函数 解决浅拷贝带来的问题
	person(const person& p) 
	{
		cout << "Person 拷贝构造函数"<<endl;
		m_age = p.m_age;
			//m_Height = p.m_Height
		m_Height = new int(*p.m_Height);
	}
	~person() {
		//析构代码，将堆区开辟的数据做释放操作
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;//目的是为了防止野指针的出现
		}
		cout << "这是一个析构函数" << endl;
	}
};
void Test()
{
	person p1(18,160);
	cout << "p1的年龄为：" << p1.m_age << "身高为："<<*p1.m_Height << endl;
	person p2(p1);
	cout << "p2的年龄为：" << p2.m_age <<"身高为："<<*p2.m_Height << endl;
}
int main(){
	Test();
	system("pause");
	return 0;
}

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题。

4.2.6初始化列表

作用：C++提供了初始化列表语法，用来初始化属性

语法：构造函数（）：属性1（值1），属性2（值2）… {}

#include <iostream>
#include <string>
using namespace std;

class Ccar {
public:
	//传统初始化操作
	//Ccar(int aa, int bb, int cc) {
	//	mm_A = aa;
	//	mm_B = bb;
	//	mm_C = cc;
	//}
	//初始化列表初始化属性
	Ccar(int aa, int bb, int cc):mm_A(aa), mm_B(bb), mm_C(cc) {}//注意冒号在构造函数括号后
	int mm_A;
	int mm_B;
	int mm_C;
};
void Ttest() {
	//Ccar c(10,20,30);
	Ccar c(30,20,10);
	cout << "mm_A=" << c.mm_A << " mm_B=" << c.mm_B << " mm_C=" << c.mm_C << endl;
}

int main() {
	Ttest();
	system("pause");
	return 0;
}

4.2.7 类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

B类中有对象A作为成员，A为对象成员

那么当创建B对象时，A与B的构造和析构顺序是谁先谁后呢？

#include <iostream>
#include <string>
using namespace std;

//类对象作为类成员
class Phone {
public:
	Phone(string name) {
		Pname = name;
		cout << "Phone的构造函数" <<
			endl;
	}
	~Phone()
	{
		cout << "Phone 析构函数的调用" << endl;
	}
	//手机的品牌名
	string Pname;
};
class Father 
{
public:
	//为什么Father的构造函数里边第二项不传入Phone类型而是传入string，因为进行了 隐式转换法：即Phone Fphone = Pname
	Father(string name, string Pname) :Fname(name), Fphone(Pname) { cout << "Father 的构造函数调用" << endl; }
	//姓名
	string Fname;
	//手机
	Phone Fphone;
	~Father() 
	{
		cout << "Father 析构函数的调用" << endl;
	}
};

//当其他类对象作为本类成员时，构造时候先构造类对象，再构造自身，析构的顺序又是怎样的呢？析构的顺序和构造的顺序是相反的。

void test05() 
{
	Father F("张三", "Honor");
	cout << F.Fname << "拿着" << F.Fphone.Pname << "手机" << endl;
}
int main() {
	test05();
	system("pause");
	return 0;
}

总结：析构的顺序和构造的顺序是相反的。

4.2.8静态成员

静态成员就是在成员变量和成员函数前加上关键字static,称为静态成员

静态成员分为：

1. 静态成员变量

   所有对象共享同一份数据

   在编译阶段分配内存

   类内声明，类外初始化

2. 静态成员函数

   所有对象共享一个函数。

   静态成员函数只能访问静态成员变量。

#include <iostream>
#include <string>
using namespace std;

class Dog {
public:
	//所有对象共享同一份数据

	//在编译阶段分配内存

	//类内声明，类外初始化
	static int m_A;

	//静态成员变量也是有访问权限的,类外是无法访问的。
private:
	static int m_B;

};
int Dog::m_B = 200;
int Dog::m_A = 100;//Dog作用域下的m_A的成员，这样就完成了类内声明，类外初始化的操作了。
void test06() {
	Dog d;
	cout << d.m_A << endl;
	Dog dd;
	dd.m_A = 20;
	cout << d.m_A << endl;
}
void test07() {
	//静态成员变量 不属于某个对象上，所有对象都要共享同一份数据
	//因此静态成员变量有两种访问方式

	//1.通过对象进行访问
	Dog d1;
	cout << d1.m_A << endl;
	//2.通过类名进行访问
	cout << " ******************" << endl;
	cout << Dog::m_A << endl;
	// cout << Dog::m_B << endl;  会报错，因为m_B是私有的无法访问。类外访问不到私有的静态成员变量。
}
	
int main() {
	//test06();
	test07();
	system("pause");
	return 0;
}

静态成员函数

#include <iostream>
#include <string>
using namespace std;

class Dog {
public:
	//所有对象共享同一份数据

	//在编译阶段分配内存

	//类内声明，类外初始化
	static int m_A;
	int m_C;
	//静态成员函数
	static void func() 
	{
		m_A = 1000; //静态成员函数可以访问静态成员变量
		//m_C = 200;//静态成员函数  不可以访问  非静态成员变量，因为无法区分到底是哪个对象的属性。
		cout << "static void func调用" << endl;
	}

	//静态成员变量和静态成员函数都是有访问权限的,类外是无法访问的。
private:
	static int m_B;
	static void func2() {
		cout << "static void func2调用" << endl;
	}

};
int Dog::m_B = 200;
int Dog::m_A = 100;//Dog作用域下的m_A的成员，这样就完成了类内声明，类外初始化的操作了。
void test06() {
	Dog d;
	cout << d.m_A << endl;
	Dog dd;
	dd.m_A = 20;
	cout << d.m_A << endl;
}
void test07() {
	//静态成员变量 不属于某个对象上，所有对象都要共享同一份数据
	//因此静态成员变量有两种访问方式

	//1.通过对象进行访问
	Dog d1;
	cout << d1.m_A << endl;
	//2.通过类名进行访问
	cout << " ******************" << endl;
	cout << Dog::m_A << endl;
	// cout << Dog::m_B << endl;  会报错，因为m_B是私有的无法访问。类外访问不到私有的静态成员变量。
}
void test08() {
	//1.通过对象访问
	Dog d2;
	d2.func();
	//2.通过类名访问
	Dog::func();

	//Dog::func2(); // 类外访问不到私有的静态成员函数。
}
int main() {
	//test06();
	//test07();
	test08();
	system("pause");
	return 0;
}

4.3C++对象密续部分和this指针

4.3.1成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上。

#include <iostream>
#include <string>
using namespace std;

//成员变量和成员函数是分开存储的。
class Person {
	int m_A;//非静态成员变量  属于类的对象上。
	static int m_B;//静态成员变量  不属于类对象上
	void func() {}  //非静态成员函数  不属于类的对象上
	static void func2() {}//静态成员函数  只有一份大家共享，不属于类的对象上。
};
void test01() {
	Person p;
	//空对象占用的内存空间为：一个字节
	//C++编译器给每个空对象(此时Person类里边什么都没有)也分配一个字节的空间，为了区分空对象占内存的位置
	//每个空对象也应该有一个独一无二的内存地址
	cout << "size of p = " << sizeof(p) << endl;
}

void test02() {
	Person p1;
	cout << "size of p1 = " << sizeof(p1) << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

4.3.2 this指针

通过4.3.1我们知道在C++中成员变量和成员函数是分开存储的

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码。

那么问题是：这一块代码是如何区分那个对象调用自己的呢？

C++通过提供特殊的对象指针，this指针，解决上述问题，this指针指向被调用的成员函数所属的对象。

this指针是隐含每个非静态成员函数内的一种指针

this指针不需要定义，可以直接使用

this指针的用途：

1. 当形参和成员变量同名时，可用this指针来区分
2. 在类的非静态成员函数中返回对象本身，可以使用return *this

#include <iostream>
#include <string>
using namespace std;

//1.解决名称冲突

class person {
	public:
		int age;//m的意思是member,解决冲突的两个办法：1.在定义成员变量时使用   m_成员名，2.加上this指针
		person(int age)
		{	//this指针指向的是被调用的成员函数所属的对象
			this->age = age;
		}
		//要返回本体的话需要用引用的方式做返回
		//用值的方式（不加&）返回的话会创建一个新的对象，用引用的方式返回的话不会创建新的对象
		person& PersonAddAge(person& p) {
			this->age += p.age;//将p的年龄加到自身上。
			//只有该返回值还是person的话才能不断调用该函数
			//this指向的是调用该函数的类对象，*this就是指向本体。
			return *this;
		}
};

void test03() {
	person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;
}
//2.返回对象本身
void test04() {
	person p2(10);
	person p3(10);

	//链式编程的思想。
	p3.PersonAddAge(p2).PersonAddAge(p2).PersonAddAge(p2);
	cout<< "p3的年龄为：" << p3.age << endl;
}
int main() {
	//test03();
	test04();
	system("pause");
	return 0;
}

4.3.3空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是需要注意有没有用到this指针

如果用到this指针，需要加以判断代码的健壮性（鲁棒性）

4.3.4 const修饰成员函数

常函数：

​ 成员函数后加const后我们成为这个函数为常函数。

​ 常函数内不可以修改成员属性。

​ 成员属性声明时加关键字mutable后，在常函数中依然可以修改。

常对象：

​ 声明对象前加const称该对象为常对象

​ 常对象只能调用常函数

#include <iostream>
#include <string>
using namespace std;

//1.解决名称冲突

class person {
	public:
		int age;//m的意思是member,解决冲突的两个办法：1.在定义成员变量时使用   m_成员名，2.加上this指针
		person(int age)
		{	//this指针指向的是被调用的成员函数所属的对象
			this->age = age;
		}
		//要返回本体的话需要用引用的方式做返回
		//用值的方式（不加&）返回的话会创建一个新的对象，用引用的方式返回的话不会创建新的对象
		person& PersonAddAge(person& p) {
			this->age += p.age;//将p的年龄加到自身上。
			//只有该返回值还是person的话才能不断调用该函数
			//this指向的是调用该函数的类对象，*this就是指向本体。
			return *this;
		}
};
class car {
public:
	void showName() {
		cout << "这是一个name展示:" << endl;
	}
	void showAge() {
		//加上一个if判断使得代码更具鲁棒性，当其为NULL时就直接return掉，否则的话执行下边的输出。从而解决了崩掉问题。
		if (this == NULL) {
			return;
		}
		cout << "这个汽车的使用年限是：" << m_age <<endl;
	}
	int m_age;
};
//常函数和常对象
class dog {
public:
	int m_A;
	mutable int m_B;//特殊变量，即使在常函数中，也可以修改这个值,加上mutable关键字，即使在常函数中也是可以修改的。
	//this指针的本质是指针常量  指针的指向是不可以更改的。
	//如果不想要修改m_A的话就在函数后边加上 const
	//const dog *const this;
	//在成员函数后边加上const 修饰的是this指针的指向，让指针指向的值也不可以修改。
	void showdog() const {
		this->m_B = 100;
		//this->m_A = 100;//这时在函数后边加上的const相当于上一句话dog前边的const，则指针指向的值不可以更改。
		//this = NULL;//this指针不可以修改指针的指向。一旦实例化对象以后this就指向这个对象了。
	}
	void func() {}
};
void test03() {
	person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;
}
//2.返回对象本身
void test04() {
	person p2(10);
	person p3(10);

	//链式编程的思想。
	p3.PersonAddAge(p2).PersonAddAge(p2).PersonAddAge(p2);
	cout<< "p3的年龄为：" << p3.age << endl;
}
void test05() {
	car* c = NULL;
	c->showName();
	c->showAge();
}
void test06() {
	dog d;
	d.showdog();
}
//常对象
void test07() {
	const dog d1;//在对象前加上const,变为常对象
	//d1.m_A = 100;
	d1.m_B = 200;//m_B是特殊值，在常对象下也是可以修改的。

	//常对象只能调用常函数
	d1.showdog();
	//d1.func();常对象不可以调用普通的成员函数
}
int main() {
	//test03();
	//test04();
	//test05();
	//test06();
	test07();
	system("pause");
	return 0;
}

4 .4友元

e.g.生活中你的家有客厅，卧室

客厅所有来的客人都是可以进去的，但是你的卧室是私有的，也就是说只有你自己能进去

但是呢，你也可以允许你的好基友进去。

在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元技术

友元技术的目的就是然一个函数或者类访问另一个类中的私有成员。

友元关键字为：friend

友元的三种实现

1. 全局函数做友元
2. 类做友元
3. 成员函数做友元

#include <iostream>
#include <string>
using namespace std;

//全局函数做友元
//类做友元
//成员函数做友元
//class GoodGay1;
class Building;
class GoodGay1 {

public:
	GoodGay1();
	void visit();//特殊的函数，用于Building的友元。
	void visit2();
public:
	Building* building;
};
class Building {
	//来自于godgay类成员函数的友元
	friend void GoodGay1::visit();
	//GoodGay是Building类的友元类。
	friend class GoodGay;
	//goodGay全局函数是Building的好朋友，可以访问Building中的私有成员。只要卸载类上边就可以。
	friend void goodGay(Building &build);
public:
	string m_SittingRoom;//客厅
	Building() {
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
private:
	string m_BedRoom;//卧室
};
class GoodGay {
public:
	GoodGay();
	void vist();//参观函数  访问Building属性
	Building* building;

};
//class GoodGay1 {
//
//public:
//	GoodGay1();
//	void visit();//特殊的函数，用于Building的友元。
//	void visit2();
//public:
//	Building* building;
//};
GoodGay1::GoodGay1() {
	building = new Building;
}
void GoodGay1::visit() {
	cout << "visit 正在访问：" << building->m_SittingRoom << endl;
	cout << "visit 正在访问：" << building->m_BedRoom << endl;
}
void GoodGay1::visit2() {
	cout << "visit2 正在访问：" << building->m_SittingRoom << endl;
	//cout << "visit2 正在访问：" << building->m_BedRoom << endl;
}
//类外实现成员函数
GoodGay::GoodGay() {
	//创建建筑无对象
	building = new Building;
}
void GoodGay::vist() {
	cout << "好基友正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友正在访问：" << building->m_BedRoom << endl;
}
void goodGay(Building &build) {
	//访问Building中的属性
	cout << "好基友全局函数  正在访问：" << build.m_SittingRoom << endl;
	cout << "好基友全局函数  正在访问：" << build.m_BedRoom << endl;
}
void test08() {
	Building building;
	goodGay(building);
}
void test09() {
	GoodGay G;
	G.vist();
}
void test10() {
	GoodGay1 ggd;
	ggd.visit();
	ggd.visit2();
}
int main() {
	//test08();
	test10();
	system("pause");
	return 0;
}

可以看下这个链接，关于类的位置摆放带来的问题

https://blog.youkuaiyun.com/strive_max/article/details/127947510

4.5运算符重载

运算符重载的概念：对已有的运算符重新定义，赋予器另一种功能，以适应不同的数据类型

4.5.1 加减乘除运算符重载

对于内置数据类型，编译器知道如何进行运算

加法运算符重载

#include <iostream>
#include <string>
using namespace std;
//运算符重载

class Cat{
public:
	//Cat operator+(Cat &c) {
	//	Cat temp;
	//	temp.m_A = this->m_A + c.m_A;
	//	temp.m_B = this->m_B + c.m_B;
	//	return temp;
	//}
	int m_A;
	int m_B;
};
//2.全局函数重载+号
Cat operator+(Cat& c, Cat& c1) {
	Cat temp;
	temp.m_A = c1.m_A + c.m_A;
	temp.m_B = c1.m_B + c.m_B;
	return temp;
} 
Cat operator+(Cat& c, int c1) {
	Cat temp;
	temp.m_A = c1 + c.m_A;
	temp.m_B = c1 + c.m_B;
	return temp;
}
void test11() {
	Cat c;
	c.m_A = 10;
	c.m_B = 10;
	Cat c1;
	c1.m_A = 10;
	c1.m_B = 10;
	Cat c2 = c + c1;
	Cat c3 = c + 100;//cat + int类型的加法
	cout << "c2.m_A = " << c2.m_A << endl;
	cout << "c2.m_B = " << c2.m_B << endl;
	cout << "c3.m_A = " << c3.m_A << endl;
	cout << "c3.m_B = " << c3.m_B << endl;
}


int main() {
	test11();
	system("pause");
	return 0;
}

总结1：对于内置数据类型的表达式运算符是不可能改变的。

总结2：不要滥用运算符重载。

4.5.2 左移运算符重载

#include <iostream>
#include <string>
using namespace std;
//运算符重载
//左移运算符重载   “<<”

class Cat {
	friend ostream& operator<<(ostream& cout, Cat& p);
public:
	Cat(int a, int b) {
		m_A = a;
		m_B = b;
	}
private:
	int m_A;
	int m_B;
};
//引用本身是起的别名，所以cout可以换为out
ostream &operator<<(ostream &cout,Cat &p)//本质 operator<<(cout,p)简化cout<<p，这个函数的左右顺序不能换。
{
	cout << "m_A = " << p.m_A << " m_B = " << p.m_B;
	return  cout;
}

void test12() {
	Cat c(10,10);
	//c.m_A = 10;
	//c.m_B = 10;
	cout << c <<"Hello world!"<< endl;
}

int main() {
	//test11();
	test12();
	system("pause");
	return 0;
}
//为什么重载左移运算符，目的是为了直接输出这个对象，不输出对象属性就可以直接把对象中的属性打印出来。

cout属于ostream (输出流)

cin属于istream（输入流）

注意：不能使用成员函数重载 左移运算符，p.operator<<(cout) 简化后是 p<<cout

不会利用成员函数重载<<运算符，因为无法实现 cout<<在左侧，只能使用全局函数重载左移运算符

重载左移运算符可以通过友元实现访问

4.5.3递增运算符重载

作用：通过重载递增运算符，实现自己的整型数据

++a 此时a已经是加过1后的数字了，a++此时语法是还是数字a，这句话后a变为加1

int a = 10;
cout<<++a<<endl;//11
cout<<a<<endl;//11
int b = 10;
cout<<b++<<endl;//10
cout<<b<<endl;//11

#include <iostream>
#include <string>
using namespace std;

//重载递增运算符

//自定义整型数据
class MyInteger {
	friend ostream& operator<<(ostream& cout, MyInteger myint);
private:
	int m_NUM;
public:
	MyInteger() {
		m_NUM = 0;
	}
	//重载前置++运算符  返回引用是为了一直对一个数据进行递增的操作
	MyInteger& operator++() {
		//先进行++运算
		m_NUM++;
		//再将自身做返回
		return *this;
	}
	//重载后置++运算符   返回引用是为了一直对一个数据进行递增的操作  int 表示占位参数，区分前置++和后置++
	MyInteger operator++(int) {
		//先  记录当时结果     让表达式运算
		MyInteger temp = *this;
		//后让数据递增
		m_NUM++;
		//最后将记录结果做返回
		return temp;  //为什么返回的是值而不是引用，因为如果返回引用的话，相当于返回的是局部对象的引用，
		//局部对象当该函数执行完后就自动释放了，因此再返回引用的话就是非法操作
	}
};
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_NUM;
	return cout;
}
void test13() {
	MyInteger myint;
	cout << ++(++myint) << endl;
	cout << myint << endl;
}
void test14() 
{
	MyInteger myint;
	cout << (myint++)++ << endl;
	cout << myint << endl;
}
int main() {
	int a = 0;
	//test13();
	test14();
	cout << ++(++a) << endl;
	cout << a << endl;
	system("pause");
	return 0;
}

总结：前置递增返回的是引用，后置递增返回的是值。

4.5.4赋值运算符重载

C++编译器至少给一个类添加4个函数

1.默认构造函数（无参，函数体为空）

2.默认析构函数（无参，函数体为空）

3.默认拷贝构造函数，对属性进行值拷贝

4.赋值运算符operator=,对属性进行值拷贝。

赋值运算符出现的问题（深浅拷贝问题）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gXMxQutc-1685672196907)(F:\Desktop\C++\fig\f6b044663de5a6efd4b23be5884f98e.png)]

解决方案：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qzZWWCEq-1685672196908)(F:\Desktop\C++\fig\345a08a4a9dcb4285d4cdf132740cdb.png)]

#include<iostream>
#include<string>
using namespace std;

//赋值运算符重载

class PPerson {
public:
	PPerson(int age){
		m_Age = new int(age);//在堆区开放一块空间来接收age  new int 返回的是int *类型的数据
	}
	//由于在堆区创建了数据，所以做析构的时候浅拷贝会带来一定的问题，使得两个对象释放同一块内存空间。
	~PPerson() { 
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;
		}
	}
	//重载赋值运算符
	PPerson& operator=(PPerson &p) {
		//编译器执行的是浅拷贝的操作,会导致堆区内存重复释放。
		//m_Age = p.m_Age;

		//应该先判断是否有属性在堆区，如果有先释放干净，然后再进行深拷贝
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;
		}

		//进行深拷贝
		m_Age = new int(*p.m_Age);

		return *this;
	}
	int* m_Age;
};
void Test03() {
	PPerson p1(18);
	PPerson p2(20);
	PPerson p3(30);
	p3=p2 = p1;//赋值操作
	cout << "p1的年龄为：" <<*p1.m_Age <<endl;
	cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;
}
int main() {
	Test03();
	system("pause");
	return 0;
}

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题。

4.5.5关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作。

#include<iostream>
#include<string>
using namespace std;

//重载关系运算符

class Person {
public:
	Person(string name, int age) {
		m_name = name;
		m_age = age;
	}
	bool operator==(Person& p) {
		if (this->m_age==p.m_age && this->m_name==p.m_name) {
			return true;
		}return false;
	}
private:
	string m_name;
	int m_age;
};
void TTest01() {
	Person p1("Tom", 18);
	Person p2("JUM", 20);
	if (p1 == p2) {
		cout << "p1和p2是相等的。" << endl;
	}
	else { cout << "p1和p2是不相等的。" << endl; }

}
int main(){
	TTest01();
	system("pause");
	return 0;
}

4.5.6函数调用运算符重载

函数调用运算符（）也可以重载

由于重载后使用的方式非常像函数的调用，因此称之为仿函数

仿函数没有固定的写法，非常灵活

#include<iostream>
#include<string>
using namespace std;

//函数调用运算符重载
//本篇写两个类的目的是为了说明函数调用运算符()（仿函数）可以有多个方法重载

class MyPrint {
public:
	//重载函数调用运算符
	void operator() (string test){
		cout << test << endl;
	}
};

class Add {
public:
	int operator()(int num1, int num2) {
		return num1 + num2;
		}
};
//正常函数的打印输出
void myPrint02(string test) {
	cout << test << endl;
}

void ttest02() {
	MyPrint myprint;
	myprint("Hello");
}
void ttest03() {
	Add ad;
	cout<<ad(10, 10)<<endl;

	//匿名函数对象  通过  类型()会创建出来一个匿名对象，匿名对象的特点：当前行执行完后会被立即释放。
	cout << Add()(10, 10) << endl;

}
int main() {
	//ttest02();
	ttest03();
	string test = "Hello";
	myPrint02(test);
	system("pause");
	return 0;
}

C++提高编程

本阶段主要针对C++泛型变成和STL技术做详细讲解，探讨C++更深层次的使用

1.模板

1.1模板的概念

模板就是建立通用的模具，大大提高复用性

1.2函数模板

1. C++另外一种编程思想称之为***泛型编程***，主要利用的技术就是模板
2. C++提供两种模板机制 函数模板和类模板

1.2.1 函数模板语法

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>   //typename  和 class都行。
函数声明或定义

解释：

template ----声明创建模板。

typename ----表面其后面的符号是一种数据类型，可以用class代替。

T —通用的数据类型，名称可以替换，通常为大写字母。

#include <iostream>
using namespace std;

//函数模板

//两个整型数据交换的函数
void swapInt(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}

//交换两个浮点型的函数
void swapDouble(double& a, double& b) {
	double temp = a;
	a = b;
	b = temp;
}

//函数模板
template<typename T>
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01() 
{
	int a = 10;
	int b = 20;
	
	//swapInt(a,b)
	//利用函数模板交换
	//两种方式使用函数模板
	//1.自动类型推导
	mySwap(a, b);
	//2.显示指定类型  mySwap<模板参数>（a，b）
	mySwap<int>(a, b);
	//swapInt(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;


}
int main() 
{
	test01();
	system("pause");
	return 0;
}

1.2.2函数模板注意事项

注意事项：

1. 自动类型推导，必须推导出一致的数据类型T，才可以使用
2. 模板必须要确定出T的数据类型，才可以使用

#include <iostream>
using namespace std;

//函数模板
template<typename T> //其中的typename 可以替换为class
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01() 
{
	int a = 10;
	int b = 20;
	char c = 'c';
	
	//swapInt(a,b)
	//利用函数模板交换
	//两种方式使用函数模板
	//1.自动类型推导
	mySwap(a, b);
	//2.显示指定类型  mySwap<模板参数>（a，b）
	mySwap<int>(a, b);
	//swapInt(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	//3.自动类型推导，必须推导出一致的数据类型T，才可以使用
	//mySwap(a, c); //报错的原因是因为a,c的数据类型不一致，无法推导出相应的T。

}
//4. 模板必须要确定出T的数据类型，才可以使用
template <class T>
void func()
{
	cout << "func的函数调用" << endl;
}
//注意此时函数不需要传入参数了，因此没有办法知道数据类型，所有该函数想要成为模板函数的话，下边test02()调用只能是随便指定一个模板参数  e.g.int  或者double等
void test02() {
	func<int>();
}

int main() 
{
    test02();
	test01();
	system("pause");
	return 0;
}

1.2.3 函数模板案例

案例描述：

1. 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
2. 排序规则从大到小，排序算法为选择排序
3. 分别利用char数组和int数组进行测试

#include <iostream>
#include <string>
using namespace std;
//实现通用对数组进行排序的函数
//规则从大到小
//算法 选择
//测试 char数组、int 数组

//交换函数模板
template<class T>
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}
//排序算法
template<typename T>
void mySort(T arr[],int len) 
{
	for (int i = 0; i < len; i++) {
		int max = i;//认定最大值的下标
		for (int j = i + 1; j < len; j++) {
			//我们认定的最大值比遍历出的数值小，说明j下表的元素才是真正的最大值
			if (arr[max] < arr[j])
			{
				max = j;//更新最大值下标
			}
		}
		if (max != i) 
		{
			//交换max和i元素
			mySwap(arr[max], arr[i]);
		}
	}
}
//打印数组的模板
template<class T>
void printArray(T arr[],int len) {
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}


void test03() {
	//测试char数组
	char charArr[] = "badcef";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
}

void test04() {
	//测试int数组
	int intArr[] = { 7,5,1,3,9,2,4,6,8 };

	int num = sizeof(intArr) / sizeof(int);

	mySort(intArr, num);

	printArray(intArr, num);
}
int main() 
{
	//test03();
	test04();
	system("pause");
	return 0;
}

1.2.4普通函数和函数模板的区别

普通函数与函数模板区别：

1. 普通函数调用时可以发生自动类型转换（隐式类型转换）
2. 函数模板调用时，如果利用好自动类型推导，不会发生隐式类型转换
3. 如果利用显示指定类型的方式，可以发生隐式类型转换。

#include <iostream>
#include <string>
using namespace std;

//普通函数与函数模板的区别

//1.普通函数调用可以发生隐式类型转换
//2. 函数模板 用自动类型推导，不可以发生隐式类型转换。
//3. 函数模板 用显示指定类型，可以发生隐式类型转换。

//普通函数   在调用时是可以发生隐式类型转换的。
int myAdd(int a, int b) 
{
	return a + b;
}


//函数模板
template <class T>
int myAdd01(T a, T b) 
{
	return a + b;
}

void test05() 
{
	int a = 10;
	int b = 20;
	char c = 'c';


	cout << myAdd(a, c) << endl;//此时没有发生报错进行了隐式类型转换。将字符c转换为相应的ASCII码。然后执行了相加。
	
	//自动类型推导时，不会进行类型转换，将字符型转换为整型。
	//cout << myAdd01(a, c) << endl;

	//显示指定类型，会进行隐式类型转换的，e.g.明确告诉我们就把T推导成int类型，如果不是的话就进行类型转换就好，再放到函数中进行操作。
	cout << myAdd01<int>(a, c) << endl;
}

int main() {
	test05();
	system("pause");
	return 0;
}

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

调用规则如下：

1. 如果普通函数和函数模板都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产生更好的匹配，优先调用函数模板

#include <iostream>
#include <string>
using namespace std;

//普通函数与函数模板调用规则
//1.如果函数模板和普通函数都可以调用，优先调用普通函数
//2.可以通过空模板参数列表  强制调用  函数模板
//3. 函数模板也可以发生函数重载
//4.如果函数模板可以产生更好的匹配，优先调用函数模板

//普通函数
void myPrint(int a, int b)
{
	cout << "调用的普通函数" << endl;
}
//函数模板
template <class T>
void myPrint(T a, T b) {
	cout << "调用的模板" << endl;
}

template <class T>
void myPrint(T a, T b,T c) {
	cout << "调用的重载模板" << endl;
}

void test06() 
{
	int a = 10;
	int b = 20;
	int c = 30;

	//myPrint(a, b);

	通过空模板参数列表，强制调用函数模板
	//myPrint<>(a, b);

	myPrint(a, b, c);

	//如果函数模板产生更好的匹配，优先调用函数模板。
	char d1 = 'a';
	char d2 = 'b';
	myPrint(d1, d2);//运行后调用的是模板。因为编译器认为要是
	//调用普通函数的话还需要做一个隐式类型转换，要是调用模板的话直接把T推导为char就行。



}

int main() 
{
	test06();
	system("pause");
	return 0;
}

总结：

既然提供了函数模板，最好不要提供普通函数，否则容易出现二义性

1.2.6模板的局限性

局限性：

​ 1. 模板的通用性并不是万能的

例如：

template <class T>
void f(T a,T b)
{
    a = b;
}

在上述代码中提供的赋值操作，如果传入的a和b是一个数组的话，就无法实现了

再例如：

template <class T>
void f(T a,T b)
{
    if(a > b){.....}
}

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也是无法正常运行的。

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

#include <iostream>
#include <string>
using namespace std;

//模板局限性
//模板并不是万能的，有些特定数据类型，需要用具体化方式做特殊实现。

//自定义数据类型
class Person
{
public:
	Person(string name, int age) 
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;

};

//对比两个数据是否相等
template <class T>
bool myCompare(T& a, T& b)
{
	if (a == b) {
		return true;
	}
	else 
	{ 
		return false;
	}
}

//利用具体化Person的版本实现重载代码，具体化优先调用
template<> bool myCompare(Person& a, Person& b) {
	if (a.m_name == b.m_name && a.m_age == b.m_age) 
	{
		return true;
	}
	else
	{
		return false;
	}
}

void test07() 
{
	int a = 10;
	int b = 20;

	bool ret = myCompare(a, b);

	if (ret)
	{
		cout << "a==b" << endl;
	}
	else 
	{
		cout << "a!= b" << endl;
	}

}
void test08() {
	Person p1("Tom", 15);
	Person p2("Tom", 16);

	bool ret = myCompare(p1, p2);
	if (ret) 
	{
		cout << "p1 == p2" << endl;
	}
	else
	{
		cout << "p1 != p2" << endl;
	}
}
int main() 
{
	//test07();
	test08();
	system("pause");
	return 0;
}

总结：

利用具体化的模板，可以解决自定义类型的通用化

学习模板并不是为了写模板，而是在STL能够运用系统提供的模板。

1.3类模板

1.3.1 类模板语法

类模板作用：

建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表

语法：

template<typename T>
类

解释：

template --声明创建模板

typename --表面其后面的符号是一种数据类型，可以用class代替

T —通用的数据类型，名称可以替换，通常为大写字母

#include <iostream>
#include <string>
using namespace std;
//类模板的基本语法
template <class NameType,class AgeType>
class Person 
{
public:
	Person(NameType name, AgeType age) 
	{
		this->m_age = age;
		this->m_name = name;
	}
	NameType m_name;
	AgeType m_age;
	void myPrint() {
		cout << "姓名:" << this->m_name << " 年龄：" << this->m_age << endl;
	}
};

void test09() {
	Person<string,int> p1("张三", 32);
	p1.myPrint();
}

int main() {
	test09();
	system("pause");
	return 0;
}

总结：类模板与函数模板非常相似，在声明模板template后面加上类，此类称之为类模板。

1.3.2类模板和函数模板的区别

类模板和函数模板的区别主要有两点：

1. 类模板没有自动推导类型
2. 类模板在模板参数列表中可以有默认参数

#include <iostream>
#include <string>
using namespace std;

//类模板和函数模板的区别
template <class Nametype,class Agetype = int>
class PPerson {
public:
	PPerson(Nametype name, Agetype age)
	{
		this->m_age = age;
		this->m_name = name;
	}

	Nametype m_name;
	Agetype m_age;
	void myPrint() {
		cout << "姓名:" << this->m_name << " 年龄：" << this->m_age << endl;
	}

};
//类模板没有自动推导的使用方式
void test10() {
	//PPerson p("黑暗", 100);错误无法使用自动推导类型
	PPerson<string, int> p("网文", 21);
	p.myPrint();
	PPerson<string> p1("张三", 22);//只有类模板才可以在一开始就指定类型。
	p1.myPrint();
}

int main() {
	test10();
	system("pause");
	return 0;
}

总结: 1.类模板的使用 只能使用显示指定类型的方式

		2. 类模板中的模板参数列表可以有默认参数。

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

类模板中成员函数和普通类中成员函数创建时机是有区别的：

1. 普通类中的成员函数一开始就可以创建
2. 类模板中的成员函数在调用时才可以创建

#include <iostream>
#include <string>
using namespace std;

//类模板中成员函数的创建时机
//类模板中成员函数在调用时才去创建

class Person1 {
public:
	void myPrint1() {
		cout << "Show Person1"<< endl;
	}

};

class Person2 {
public:
	void myPrint2() {
		cout << "Show Person2" << endl;
	}

};

template<class T>
class Myclass 
{
public:
	T obj;
	//类模板中的成员函数
	//类模板中的成员函数obj无法创建myPrint1函数，直到你调用的时候确定了obj是什么数据类型才创建
	void func1()
	{
		obj.myPrint1();
	}
	void func2()
	{
		obj.myPrint2();
	}
};

void test11() {
	Myclass<Person1>m;
	m.func1();
	//m.func2();
}
int main() 
{
	test11();
	system("pause");
	return 0;
}

总结：类模板中的成员函数并不是一开始就创建的，而是在调用时才去创建的。

1.3.4 类模板对象做函数参数

学习目标：

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

一共有三种传入方式：

1. 指定传入的类型----直接显示对象的数据类型（常用的方式）
2. 参数模板化 -------将对象中的参数变为模板进行传递
3. 整个类模板化 ----将这个对象类型模板化进行传递

#include <iostream>
#include <string>
using namespace std;

//类模板对象做函数参数
template <class T1,class T2>
class person
{
public:
	person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	T1 m_name;
	T2 m_age;
	void showPerson()
	{
		cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
	}
};
//1.指定传入类型   类模板的对象做函数中的参数
void printPerson1(person<string, int>& p)
{
	p.showPerson();
}

void test12() 
{
	person<string, int>p2("张三", 22);
	printPerson1(p2);

}
//2.参数模板化
template <class T1, class T2>
void printPerson2(person<T1, T2>& p)
{
	p.showPerson();
	cout << "T1的类型为：" << typeid(T1).name() << endl;
	cout << "T2的类型为：" << typeid(T2).name() << endl;

}

void test13()
{
	person<string, int>p2("里斯", 22);
	printPerson1(p2);

}
//3.整个类模板化
template <class T>
void printPerson2(T &p)
{
	p.showPerson();
	cout << "T的类型为：" << typeid(T).name() << endl;
	

}
void test14()
{
	person<string, int>p2("王五", 24);

	printPerson1(p2);

}

int main() 
{
	test12();
	test13();
	test14();
	system("pause");
	return 0;
}

1.3.5类模板和继承

当类模板碰到继承的时候，需要注意以下几点：

1. 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中的类型
2. 如果不指定，编译器无法给子类分配内存。
3. 如果想灵活指定出父类中的T类型，子类也需要变为类模板。

#include <iostream>
#include <string>
using namespace std;

//类模板与继承
template<class T>
class Base 
{
public:
	T m;
};
//class Son :public Base   //错误，必须要知道父类中的T类型，才能继承给子类
class Son :public Base<int>
{

};
void test15() 
{
	Son s1;
}

//如果想灵活指定父类中T类型，子类也需要变为类模板
template<class T1,class T2>
class Son2 :public Base<T2>
{
public:
	Son2() 
	{
		cout << "T1的数据类型为：" << typeid(T1).name() << endl;
		cout << "T2的数据类型为：" << typeid(T2).name() << endl;
	}
	T1 obj;
};
void test16() 
{
	Son2 <int, char>S2;
}
int main() 
{
	test16();
	system("pause");
	return 0;
}

总结：如果父类是类模板，子类需要指定出父类中T的数据类型。

1.3.6类模板成员函数的类外实现

学习目标：能够掌握类模板中的成员函数类外实现

#include <iostream>
#include <string>
using namespace std;

//类模板成员函数的类外实现
template <class T1,class T2>
class pperson
{
public:
	pperson(T1 name, T2 age);
		//{
		//	this->m_Name = name;
		//	this->m_Age = age;
		//}
	void sshowPerson();
	//{
	//	cout << "姓名：" << this->m_Name << "年龄：" << this->m_Age << endl;
	//}
	T1 m_Name;
	T2 m_Age;
};
//构造函数的类外实现
template <class T1, class T2>
pperson<T1, T2>::pperson(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}
//成员函数的类外实现
template <class T1, class T2>
void pperson<T1,T2>::sshowPerson()
//void sshowPerson()
{
		cout << "姓名：" << this->m_Name << "年龄：" << this->m_Age << endl;
}
void test() 
{
	pperson<string, int>P("Tom", 25);
	P.sshowPerson();
	
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：类模板中成员函数类外实现时，需要加上模板参数列表

1.3.7 类模板的分文件编写

学习目标：

1. 掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：

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

解决：

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

解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp时约定的名称，并不是强制。

#include <iostream>
#include <string>

//第一种解决方式，直接包含源文件，把 .h文件改为.cpp文件
//#include "person.h"
using namespace std;
#include "person.hpp" 
//第二种解决方式，将.h文件和.cpp文件中的内容写到一起，将后缀名改为.hpp,然后引用hpp文件

//类模板的分文件编写问题以及解决
//
//template <class T1,class T2>
//class PPerson1 
//{
//public:
//	PPerson1(T1 name, T2 age);
//	void sshowPerson();
//	T1 m_Name;
//	T2 m_Age;
//};

//template <class T1, class T2>
//PPerson1<T1, T2>::PPerson1(T1 name, T2 age)
//{
//	this->m_Name = name;
//	this->m_Age = age;
//}
成员函数的类外实现
//template <class T1, class T2>
//void PPerson1<T1, T2>::sshowPerson()
//{
//	cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
//}
void test18() 
{
	PPerson1<string, int>p("JAM", 25);
	p.sshowPerson();
}
int main() 
{
	test18();
	system("pause");
	return 0;
}
//类模板中的成员函数创建时机时在调用阶段，一开始不创建，从而产生无法解析的外部命令，第一种解决方法直接包含.cpp。第二种方法是包含.hpp文件进行操作。

总结：主流的解决方式为第二种，将类模板成员函数写到一起，并将后缀名改为.hpp文件

1.3.8类模板和友元

学习目标：掌握类模板配合友元函数的类内和类外实现。

全局函数类内实现：直接在类内声明友元即可

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

#include <iostream>
#include <string>
using namespace std;

//通过全局函数打印PPerson的信息

template <class T1, class T2>
class PPERSON;
//全局函数 类外实现
template <class T1, class T2>
void printPPERSON1(PPERSON<T1, T2> p)
{
	cout << "类外实现——姓名：" << p.m_name << " 年龄:" << p.m_age << endl;
}

template <class T1,class T2>
class PPERSON
{
	//全局函数类内实现
	friend void printPPERSON(PPERSON<T1, T2> p)
	{
		cout << "姓名：" << p.m_name << " 年龄:" << p.m_age << endl;
	}
	//全局函数  类外实现
	//加空模板参数列表
	//如果全局函数是类外实现的化，需要让编译器提前知道这个函数的存在。一种简单的方法就是把函数写在前边，同时让其知道类的存在
	friend void printPPERSON1<>(PPERSON<T1, T2> p);

public:
	PPERSON(T1 name,T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}

	~PPERSON()
	{
	}

private:
	T1 m_name;
	T2 m_age;
};

void test20() 
{
	PPERSON<string,int>p("张三", 20);
	printPPERSON(p);
}


void test21() {
	PPERSON<string, int>p("王五", 22);
	printPPERSON1(p);
}
int main() 
{
	//test20();
	
	test21();
	system("pause");
	return 0;
}

总结：建议全局函数做类内实现，用法简单，而且编译器也可以直接识别。

1.3.9 类模板的相关案例

案例描述：实现一个通用的数组类，要求如下：

1. 可以对内置数据类型以及自定义数据类型的数据进行存储
2. 将数组中的数据存储到堆区
3. 构造函数中可以传入数组的容量
4. 提供对应的拷贝构造函数以及operator= 防止浅拷贝问题出现
5. 提供尾插法和尾删法对数组中的数据进行增加和删除
6. 可以通过下表的方式访问数组中的元素
7. 可以获取数组中当前元素个数和数组的容量。

//MyArray.hpp文件
//自己的通用数组类
#pragma once 
#include <iostream>
#include <string>
using namespace std;

template<class T>
class MyArray
{
public:
	//有参构造 参数  容量
	MyArray(int capacity)
	{
		//cout << "Myarray的有参构造调用"<<endl;
		this->m_C = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_C];
	}
	//拷贝构造函数
	MyArray(const MyArray& arr)
	{
		//cout << "Myarray的拷贝构造调用" << endl;
		this->m_C = arr.m_C;
		this->m_Size = arr.m_Size;
		//this->pAddress = arr.pAddress;  浅拷贝
		//潜拷贝的问题会导致堆区的数据重复释放
		
		//深拷贝
		this->pAddress = new T[arr.m_C];
		//假设数组中有数据了，还要将arr中的数据都拷贝过来
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}
	//重载一个operator=防止浅拷贝问题  a =b=c
	MyArray& operator=(const MyArray &arr) 
	{
		//cout << "Myarray的重载=调用" << endl;
		//先判断原来堆区是否有数据，如果有先释放干净
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_C = 0;
			this->m_Size = 0;
		}

		//深拷贝
		this->m_C = arr.m_C;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[arr.m_C];
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
		return *this;
	}
	//尾插法
	void push_Back(const T &val) 
	{
		//判断容量是否已经等于大小了
		if (this->m_C == this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val;//在数组的末尾插入数据
		this->m_Size++;//更新数组大小
	}
	//尾删法
	void Pop_Back() 
	{
		//让用户访问不到最后一个元素，即为尾删法。逻辑上的删除
		if (this->m_Size == 0)
		{
			return;
		}
		this->m_Size--;
	}

	//通过下表的方式访问数组中的元素
	//由于无法访问arr[0]号元素，因此想要访问的话就需要重载[]运算符  
	//要想让返回的值作为左值存在，还需要返回的是T的引用才可以。
	T& operator[](int index)
	{
		return this->pAddress[index];
	}
	//返回数组的容量
	int getCapacity()
	{
		return this->m_C;
	}
	//返回数组大小 
	int getSize()
	{
		return this->m_Size;
	}
	//析构函数
	~MyArray() 
	{
		if (this->pAddress != NULL) 
		{
			//cout << "Myarray的析构调用" << endl;
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}
private:
	T* pAddress;//指针指向堆区开辟的真实数组

	int m_C;//数容量

	int m_Size;//数组大小
};

#include <iostream>
#include <string>
using namespace std;
#include "MyArray.hpp"

void PrintIntArray(MyArray<int>& arr)
{
	for (int i = 0; i < arr.getSize(); i++) {
		cout << arr[i] << endl;
	}
}

void test22()
{
	MyArray<int>arr1(5);//有参构造
	for (int i = 0; i < 5; i++)
	{
		//利用尾插法向数组中插入数据
		arr1.push_Back(i);
	}
	cout << "arr1的打印输出为：" << endl;
	
	PrintIntArray(arr1);

	cout << "arr1的容量是：" <<arr1.getCapacity() <<endl;
	cout << "arr1的大小是：" << arr1.getSize() << endl;
	
	MyArray<int>arr2(arr1);
	cout << "arr2的打印输出为：" << endl;

	PrintIntArray(arr2);

	//尾删
	arr2.Pop_Back();
	cout << "arr2尾删后:" << endl;
	cout << "arr2的容量是：" << arr2.getCapacity() << endl;
	cout << "arr2的大小是：" << arr2.getSize() << endl;


	//MyArray<int>arr2(arr1);//拷贝构造函数调用
	//MyArray<int>arr3(100);//有参构造
	//arr3 = arr1;//等号赋值运算符

}

//测试自定义数据类型
class Pperson
{
public:
	Pperson() {};
	Pperson(string name, int age) 
	{
		this->m_name = name;
		this->m_age = age;
	}


	string m_name;
	int m_age;
};

void PrintPpersonArray(MyArray<Pperson>&arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << "姓名：" << arr[i].m_name << " 年龄：" << arr[i].m_age << endl;
	}
}

void test23() 
{
	MyArray<Pperson>arr(10);

	Pperson p1("孙悟空", 25);
	Pperson p2("韩信", 27);
	Pperson p3("妲己", 21);
	Pperson p4("赵云", 28);
	Pperson p5("安琪拉", 24);
	Pperson p6("后裔", 22);

	//将数据插入到数组中
	arr.push_Back(p1);
	arr.push_Back(p2);
	arr.push_Back(p3);
	arr.push_Back(p4);
	arr.push_Back(p5);
	arr.push_Back(p6);

	//打印数组
	PrintPpersonArray(arr);

	//输出容量
	cout << "arr的容量为：" << arr.getCapacity() << endl;

	//输出大小
	cout << "arr的大小为：" << arr.getSize() << endl;

}

int main()
{
	test23();
	//test22();
	system("pause");
	return 0;
}

这个案例考察的还是很多的，含金量比较高一些。

2.STL初识

2.1 STL的诞生

长久以来，软件界一直希望建立一种可重复利用的东西。

C++的面向对象和泛型编程思想，目的就是复用性的提升。

大多数情况下，数据结构和算法都未能有一套标准，导致被迫从事大量的重复性工作

为了建立数据结构和算法的一套标准，诞生了STL。

2.2 STL的基本概念

STL（Standard Template Library,标准模板库）

STL 从广义上分为:容器、算法、迭代器

容器和算法之间通过迭代器进行无缝连接。

STL几乎所有的代码都采用了模板类或者模板函数

2.3STL六大组件

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

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

2.4 STL中容器、算法、迭代器

容器：置物之所也

STL容器就是将运用最广泛的一些数据结构实现出来。

常用的数据结构：数组、链表、树、栈、队列、集合、映射、表等

这些容器分为：序列式容器和关联式容器

​ 序列式容器：强调值的排序，序列是容器中的每个元素均有固定的位置。

​ 关联式容器：二叉树结构，各个元素之间没有严格的物理上的顺序关系。

算法：问题之解法也

有限的步骤，解决逻辑或数学上的问题，这一门学科称之为算法

算法分为：质变算法和非质变算法

质变算法：是指运算过程中会更改区间内的元素的内容，例如拷贝、替换、删除等等

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

算法需要通过迭代器才可以访问容器中的元素

迭代器：容器和算法之间的粘合剂

提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表达方式。

每个容器都有自己专属的迭代器

迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针

面向对象的三大特性

封装：把属性和行为抽象出来作为整体——类 来实现事和物，提高复用性

继承：子类继承父类，把父类的所有信息拿过来不用再重新声明一边，提高复用性

多态：一个函数有多个接口，同样都是一个函数，由于对象不同，父类指针指向子类对象，对象不同来掉用同一个接口产生不同的形态，从而产生多态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5h7H0AAI-1685672196908)(F:\Desktop\C++\fig\微信图片_20230427095129.png)]

2.5容器算法迭代器初识

STL中最常用的容器为Vector，可以理解为数组，下面我们将学习如何向这个容器中插入数据、并遍历这个容器

2.5.1 vector存放内置数据类型

容器：vector

算法：for_each

迭代器：vector::iterator

#include <iostream>
#include <string>
#include <vector>
#include <algorithm> //标准算法头文件
using namespace std;

void myPrint(int val) {
	cout << val << endl;
}
//STL每个数据类型再使用的时候都需要包含一下头文件
//vector 容器存放内置数据类型
void test01() 
{
	//创建了一个vector容器，数组
	vector<int> v;
	//向容器中插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);
	v.push_back(60);

	//通过迭代器访问容器中的数据
	//vector<int>::iterator 拿到vector<int>这种容器的迭代器类型
	vector<int>::iterator itBegin = v.begin();//起始迭代器  指向容器中第一个元素
	vector<int>::iterator itEnd = v.end();//结束迭代器  指向容器中最后一个元素的下一个位置

	第一种遍历方式
	//while (itBegin != itEnd)
	//{
	//	cout << *itBegin << endl;
	//	itBegin++;
	//}

	第二种遍历方式
	//for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	//{
	//	cout << *it << endl;
	//}

	//第三种遍历方式  利用STL提供的遍历算法
	for_each(v.begin(), v.end(), myPrint);//一开始不调用函数，在遍历期间再调用函数
}


int main01() 
{
	test01();
	system("pause");
	return 0;
}

2.5.2 vector存放自定义数据类型

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//vector 容器中存放自定义数据类型
class Person
{
public:
	Person(string name,int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;

};
void test02() 
{
	vector<Person>v;

	Person p1("张三", 10);
	Person p2("李四", 20);
	Person p3("王二", 50);
	Person p4("张柳", 21);
	Person p5("王莽", 43);

	//向容器中添加数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);

	//遍历容器   在遍历的过程中，你要知道（*it）是什么东西  首先先看<>里边是什么数据类型，<>里边的数据类型和（*it）的数据类型是一致的，在这里it的本质实际上就是一个指针
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) 
	{
		//cout << "姓名：" << (*it).m_name << " 年龄：" <<(*it).m_age<<endl;
		cout << "姓名：" << it->m_name << " 年龄：" << it->m_age << endl;
	}
}
void test03()
{
	vector<Person*>v;

	Person p1("张三", 10);
	Person p2("李四", 20);
	Person p3("王二", 50);
	Person p4("张柳", 21);
	Person p5("王莽", 43);

	//向容器中添加数据  保存住上述p1——p5的地址
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);

	//遍历容器  这里（*it）是指针，则需要用指针来访问数据
	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "::姓名：" << (*it)->m_name << " 年龄：" <<(*it)->m_age<<endl;
		//cout << "姓名：" << it->m_name << " 年龄：" << it->m_age << endl;
	}

}
int main02() 
{
	//test02();
	test03();
	system("pause");
	return 0;
}

2.5.3 Vector容器嵌套容器

学习目标：容器嵌套容器，我们将所有数据进行遍历输出

#include <iostream>
#include <string>
#include <vector>
using namespace std;

void test04() 
{
	//创建一个大容器
	vector<vector<int>>v;

	//创建一些小容器
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;
	vector<int>v4;

	//向小的容器中添加元素
	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v2.push_back(i + 4);
		v3.push_back(i + 8);
		v4.push_back(i + 16);
	}
	//向大容器中添加元素
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);

	//遍历给出相应的输出
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		//首先先搞清楚（*it）是什么，我们可以看出来（*it）也是一个容器  (*it)------容器 vector <int>
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit << " ";
		}
		cout << endl;
	}


}

int main() 
{
	test04();
	system("pause");
	return 0;
}

3.1string 容器

本质：

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

string和char *的区别

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

特点：

sting 类内部封装了很多成员方法

例如：查找 find ，拷贝 copy, 删除 delete, 替换 replace, 插入 insert

string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部及进行负责

3.1.2 string 构造函数

构造函数原型：

string(); //创建一个空字符串 例如： string str;

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

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

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

#include <iostream>
#include <string>
using namespace std;

//string的构造函数

/*string();   									//创建一个空字符串  例如：  string  str;

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

string (const string& str) ;  	//使用一个string对象初始化另外一个string对象  相当于是拷贝构造

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

void test01() 
{
	string s1;//默认构造

	const char* str = "hello world";
	string s2(str);
	cout << "s2 = " << s2 << endl;

	string s3(s2);
	cout << "s3 = " << s3 << endl;
	string s4(10, 'a');
	cout << "s4 = " << s4 << endl;
}

int main() 
{
	test01();
	system("pause");
	return 0;
}

3.1.3string的赋值操作

#include <iostream>
#include <string>
using namespace std;

//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赋给当前字符串
*/

void test02() 
{
	string str1;
	str1 = "hello world";
	cout << "str1 = " << str1 << endl;

	string str2;
	str2 = str1;
	cout << "str2 = " << str2 << endl;

	string str3;
	str3 = 'v';
	cout << "str3 = " << str3 << endl;

	string str4;
	str4.assign("Hello C++");
	cout << "str4 = " << str4 << endl;

	string str5;
	str5.assign("Hello C++",5);
	cout << "str5 = " << str5 << endl;

	string str6;
	str6.assign(10, 'e');
	cout << "str6 = " << str6 << endl;



}

int main() 
{
	test02();
	system("pause");
	return 0;
}

总结：string的赋值方式很多，operator=这种方式是比较实用的。

3.1.4 string字符串的拼接

功能描述：

实现在字符串末尾拼接字符串

函数原型

string& operator+=(const char * str); //重载+=运算符
string& operator+=(const string &str); //重载+=运算符
string& operator+=(const char c); //重载+=运算符
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个字符连接到字符串的结尾。

#include <iostream>
#include <string>
using namespace std;

void test03() 
{
	string str1 = "我";
	str1 += "爱董小姐";
	cout << "str1 = " << str1 << endl;
	str1 += ':';
	cout << "str1 = " << str1 << endl;

	string str2 = "一切的事情";
	str1 += str2;
	cout << "str1 = " << str1 << endl;

	string str3 = "I ";
	str3.append("love ");
	cout << "str3 = " << str3 << endl;
	string str4 = " this world";
	str3.append("this world", 4);
	cout << "str3 = " << str3 << endl;

	str3.append(str4);
	cout << "str3 = " << str3 << endl;

	str3.append(str4,5,6); //从第5个位置开始截取，参数三是截取的个数
	cout << "str3 = " << str3 << endl;

}

int main()
{
	test03();
	system("pause");
	return 0;
}

3.1.5 string查找和替换

功能描述

1.查找：查找指定字符串是否存在

2.替换: 在指定的位置替换字符串

函数原型：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bfrWdudk-1685672196909)(F:\Desktop\C++\fig\微信图片_20230427163216.png)]

rfind 从右往左查，find是从左往右查。

find找到字符后返回查找的第一个字符位置，找不到返回-1

replace 在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串。

#include <iostream>
#include <string>
using namespace std;


void test04() 
{
	//查找
	string str1 = "adafaf";
	int pos = str1.find("fa");

	if (pos == -1)
	{
		cout << "未找到" << endl;
	}
	else 
	{
		cout << "已经找到，pos = " << pos << endl;
	}
	pos = str1.rfind("af");

	cout << "pos = " << pos << endl;
}
void test05() 
{
	//替换
	string str1 = "adafdsafs";
	str1.replace(1, 3, "未来已来，始于现在");
	cout << "str1 = " <<str1<<endl;
}
int main()
{
	//test04();
	test05();
	system("pause");
	return 0;
}

3.1.6字符串比较

功能描述：

字符串之间的比较

比较方式

1. 字符串比较时按字符的ASCII码进行比较的

   = 返回 0

   大于 返回 1

   小于 返回 -1

函数原型：

int compare(const string &s) const; //与字符串s进行比较

int compare(const char *s) const; //与字符串s进行比较

#include <iostream>
#include <string>
using namespace std;

//字符串比较的操作  按照字符对应的ASCII码进行比较。

void test06()
{
	string str1 = "Hello";
	string str2 = "Hello";
	if (str1.compare(str2) == 0)
	{
		cout << "str1等于str2" << endl;
	}
	else if ((str1.compare(str2)) > 0)
	{
		cout << "str1大于str2" << endl;
	}
	else 
	{
		cout << "str1小于str2" << endl;
	}
}

int main()
{
	test06();
	system("pause");
	return 0;
}

3.1.7string字符存取

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

1. char& operator[ ](int n);     //通过[]方式取字符
   char& at(int n);			  //通过at方法获取字符
   
   

   #include <iostream>
   #include <string>
   using namespace std;
   
   //string 字符存取的操作
   
   void test07()
   {
   	string str = "hello";
   
   	cout << "str = " << str << endl;
   
   	//1.通过[]方式访问单个字符
   	for (int i = 0; i < str.size(); i++) 
   	{
   		cout << str[i] <<" ";
   	}
   	cout << endl;
   	//通过at方式访问单个字符
   	for (int i = 0; i < str.size(); i++)
   	{
   		cout << str.at(i) << " ";
   	}
   	cout << endl;
   
   	//修改单个字符
   	str[0] = 'x';
   	cout << "str = " << str << endl;
   
   	//也可以通过at的方式进行修改字符
   	str.at(1) = 'm';
   	cout << "str = " << str << endl;
   }
   
   int main()
   {
   	test07();
   	system("pause");
   	return 0;
   }
   
   

   总结：string字符串中单个字符的存取方式有两种，利用[ ]或at的方式

3.1.8 string 插入和删除

对string字符串进行插入和删除字符操作

函数原型

string& insert(int pos,const char *s);   			//插入字符串
string& insert(int pos,const const string& str);	//插入字符串
string& insert(int pos,int n,char c);				//在指定位置插入n个字符c
string& insert(int pos,int n = npos);				//删除从Pos开始的n个字符

#include <iostream>
#include <string>
using namespace std;

//字符串的插入和删除

void test08() 
{
	string str = "hello";

	//插入
	str.insert(1, "111"); //从某个位置起插入...前边插入
	cout << "str = " << str << endl;

	//删除
	str.erase(1, 3);  //从某个位置起删除几个元素
	cout << "str = " << str << endl;
}

int main()
{
	test08();
	system("pause");
	return 0;
}

总结：插入和删除的起始下标都是从0开始的。

3.1.9string 子串

#include <iostream>
#include <string>
using namespace std;

void test09()
{
	string str = "abcdef";
	string subStr = str.substr(1, 3);
	cout << "subStr = " << subStr << endl;
}

//实用操作
void test10()
{
	string email = "zhangying@sina.com";
	//从邮件地址中  获取用户名信息
	int pos = email.find("@");
	string userName = email.substr(0, pos);//从第0个位置起，截取pos个
	cout << userName << endl;
}



int main()
{
	//test09();
	test10();
	system("pause");
	return 0;
}

3.2vector容器

功能：vector数据结构和数组非常相似，也成为单端数组

vector与普通数组的区别：

不同之处在于数组时静态空间，而vector可以动态扩展

动态扩展：

并不是在原空间之后接续新空间，而是找到更大的内存空间，然后将原数据拷贝到新空间，释放新空间

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

3.2.2vector构造函数

功能描述：

创建你vector容器

函数原型：

1. vector<T> v;                  //采用模板实现类实现，默认构造函数
   vector(v.begin(),v.end());	  //将区间中的元素拷贝给本身
   vector(n,elem);				  //构造函数将n个elem拷贝给本身
   vector(const vector &vec);    //拷贝构造函数
   
   

   总结：vector的多种构造函数中最常用的就是拷贝构造函数，要学会灵活使用这些拷贝构造函数即可。

   #include <iostream>
   #include <string>
   #include <vector>
   using namespace std;
   
   void printVector(vector<int> &v) 
   {
   	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
   	{
   		cout << *it << " ";
   	}
   	cout << endl;
   }
   
   void test01() 
   {
   	//默认构造  无参构造
   	vector<int>v1;
   
   	for (int i = 0; i < 10; i++) 
   	{
   		v1.push_back(i);
   	}
   	printVector(v1);
   
   	//通过区间方式进行构造
   	vector<int>v2(v1.begin(), v1.end());  //拿v1的开始到结束的区间进行构造v2.
   	printVector(v2);
   	//n个elem的方式进行构造
   	vector<int>v3(10, 100);//10个100
   	printVector(v3);
   	//拷贝构造
   	vector<int>v4(v3);
   	printVector(v4);
   }
   
   int main() 
   {
   	test01();
   	system("pause");
   	return 0;
   }
   
   

   3.2.3vector的赋值操作

   给vector容器进行赋值

   函数语法：

   vector& operator=(const vector &vec);   //重载等号操作符
   assign(beg,end);						//将[beg,end）区间中的数据拷贝赋值给本身
   assign(n,ele);							//将n个elem拷贝赋值给本身
   
   

   #include <iostream>
   #include <string>
   #include <vector>
   using namespace std;
   //vector赋值
   
   void printVector1(vector<int>& v)
   {
   	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
   	{
   		cout << *it << " ";
   	}
   	cout << endl;
   }
   
   void test02() 
   {
   	vector<int>v1;
   
   	for (int i = 0; i < 10; i++)
   	{
   		v1.push_back(i);
   	}
   	printVector1(v1);
   
   	//赋值 operator=
   	vector<int>v2;
   	v2 = v1;
   	printVector1(v2);
   
   	//assign的方式进行赋值
   	vector<int>v3;
   	v3.assign(v1.begin(), v1.end());
   	printVector1(v3);
   	//assign的方式赋值为n个elem的形式
   	vector<int>v4;
   	v4.assign(10, 100);
   	printVector1(v4);
   }
   int main()
   {
   	test02();
   	system("pause");
   	return 0;
   }
   
   

   3.2.4 vector的容量和大小

对vector容器的容量和大小进行操作

函数原型：

empty();

capacity();

size();

resize(int num);

resize(int num,elem);

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//vector容器的容量和大小

void printVector2(vector<int>& v) 
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) 
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test03() 
{
	vector<int>v1;
	for (int i = 0; i < 10; i++) 
	{
		v1.push_back(i);
	}
	printVector2(v1);

	//判断v1容器是否为空
	if (v1.empty()) 
	{
		cout << "v1容器为空。" << endl;
	}
	else
	{
		cout << "v1容器不为空。" << endl;
		cout << "v1的大小为。" <<v1.size()<<endl;
		cout << "v1的容量为。" << v1.capacity() << endl;
	}
	//重新指定大小
	v1.resize(15, 100);//大小指定为15，多余的部分用100填充
	printVector2(v1);

	v1.resize(5);//大小要是少的话就截取前边的几个元素。
	printVector2(v1);
	
}

int main()
{
	test03();
	system("pause");
	return 0;
}

3.2.5 vector的插入和删除

对vector容器进行插入、删除操作

函数原型：

push_back(ele);									//尾部插入元素
pop_back();					 					//删除最后一个元素
insert(const_iterator pos,ele)  				//迭代器指向位置pos插入元素ele;
insert(const_iterator pos,intcount,ele);		//在迭代器指向位置pos插入count个元素ele;
erase(const_iterator pos);  					//删除迭代器指向的元素
erase(const_iterator start,const_iterator end);//删除迭代器从start到end之间的元素
clear();										//删除容器中所有元素

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//vector的插入和删除操作
/*
push_back(ele);									//尾部插入元素
pop_back();					 					//删除最后一个元素
insert(const_iterator pos,ele)  				//迭代器指向位置pos插入元素ele;
insert(const_iterator pos,intcount,ele);		//在迭代器指向位置pos插入count个元素ele;
erase(const_iterator pos);  					//删除迭代器指向的元素
erase(const_iterator start,const_iterator end);//删除迭代器从start到end之间的元素
clear();										//删除容器中所有元素
*/

void printVector3(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test04() 
{
	vector<int>v1;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector3(v1);

	//尾删除
	v1.pop_back();
	printVector3(v1);
	//插入  第一个参数是迭代器
	v1.insert(v1.begin(), 100);//在容器最前边插入数据100
	printVector3(v1);

	v1.insert(v1.begin(), 2, 1000);//在容器最前边插入2个数据1000
	printVector3(v1);
	//删除
	v1.erase(v1.begin());  //提供迭代器删除
	printVector3(v1);
	//提供区间进行删除
	v1.erase(v1.begin(), v1.end());
	printVector3(v1);
	//清空
	v1.clear();
	printVector3(v1);

}

int main()
{
	test04();
	system("pause");
	return 0;
}

3.2.6 vector数据存取

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//vector容器的 数据存取

void test05() 
{
	vector<int>v1;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	//利用size()函数进行操作
	for (int j = 0; j < v1.size(); j++) 
	{
		cout << v1[j] << " ";
	}
	cout << endl;
	for (int j = 0; j < v1.size(); j++) 
	{
		cout << v1.at(j) << " ";
	}
	cout << endl;
	//获取第一个元素
	cout << "vector的第一个元素为： " <<v1.front() <<endl;
	//获取最有一个元素
	cout << "vector的最后一个元素为： " << v1.back() << endl;
}

int main()
{
	test05();
	system("pause");
	return 0;
}

3.2.7容器进行交换

实现两个容器内元素进行互换

函数原型

swap(vec);//将vec与本身的元素进行互换

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//vector容器互换

void printVector4(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//1.基本使用

void test06() 
{
	vector<int>v1;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector4(v1);

	vector<int>v2;
	for (int j = 10; j > 0; j--)
	{
		v2.push_back(j);
	}
	printVector4(v2);

	//进行两个容器交换
	v1.swap(v2);
	printVector4(v1); 
	printVector4(v2);

	
}
//巧用swap容器交换进行空见收缩
void test07() 
{
	vector<int>v;
	for (int j = 0; j < 1000; j++)
	{
		v.push_back(j);
	}
	cout << "v容器的容量为：" << v.capacity() << endl;
	cout << "v容器的大小为：" << v.size() << endl;

	//重新指定容器大小
	v.resize(3);
	cout << "v容器的容量为：" << v.capacity() << endl;
	cout << "v容器的大小为：" << v.size() << endl;
	//会发现v的容器大小并没有变小，于是可以巧用swap()函数进行操作。
	vector<int>(v).swap(v);  //vector<int>(v)  匿名函数在使用完后系统会自动回收相应的空间。
	cout << "v容器的容量为：" << v.capacity() << endl;
	cout << "v容器的大小为：" << v.size() << endl;

}
int main()
{
	//test06();
	test07();
	system("pause");
	return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rZHktrj9-1685672196910)(F:\Desktop\C++\fig\微信图片_20230428110328.png)]

3.2.8 vector预留空间

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

函数原型：

reserve(int len); //容器预留len个元素的长度，预留位置不初始化，元素不可访问。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//reserve(int len)预留空间

void test08() 
{
	vector<int>v1;
	v1.reserve(1000);
	int num = 0;
	int* p = NULL;
	for (int i = 0; i < 1000; i++)
	{
		v1.push_back(i);
		if (p != &v1[0]) {
			p = &v1[0];
			num++;
		}
	}
	//记录多少次开辟新的空间，相当于一开始并不知道需要预留多少空间，然后就在加的过程中，
	//如果不够用就再次开辟新的长度的空间，依次进行下去。而如果使用reserve（int n）函数的话，就只需要依次开辟空间就够
	cout << "num = " << num << endl;

}

int main()
{
	test08();
	system("pause");
	return 0;
}

3.3 deque容器

3.3.1 deque容器基本概念

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

deque与vector区别:

1. vector对于头部的插入删除效率低，数据量越大，效率越低。
2. deque相对而言，对头部的插入删除速度会比vector快。
3. vector访问元素时的速度会比deque快，这和两者内部实现有关。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CbQvL8Dg-1685672196910)(F:\Desktop\C++\fig\微信图片_20230428140351.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MPgU4WPb-1685672196910)(F:\Desktop\C++\fig\微信图片_20230428140357.png)]

3.3.2 deque的构造函数

函数原型:

deque<T> deqT;			//默认构造形式
deque(beg,end);			//构造函数将[beg,end]区间中的元素拷贝给本身
deque(n,ele);			//构造函数将n个elem拷贝给本身。
deque(const deque &deq) //拷贝构造函数

#include <iostream>
#include <string>
#include <deque>
using namespace std;

//deque 构造函数
void printDeque(const deque<int> & d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) 
	{
		cout << *it << " ";
	}
	cout<< endl;
}


void test01() 
{
	deque<int>d1;
	for (int i = 0; i < 10; i++) 
	{
		d1.push_back(i);
	}
	printDeque(d1);
	//通过区间的方式构造函数
	deque<int>d2(d1.begin(), d1.end());
	printDeque(d2);
	//n个elem形式的构造函数
	deque<int>d3(10,100);
	printDeque(d3);
	//拷贝构造函数
	deque<int>d4(d3);
	printDeque(d4);

}

int main() 
{
	test01();
	system("pause");
	return 0;
}

注意：如果想要限定一个容器中的数据是只读状态，就需要使用const_iterator

3.3.3 deque容器的赋值操作

deque& operator = (const deque &deq); //重载等号操作符

assign(beg,end); //将[beg,end）区间中的数据拷贝赋值给本身。

assign(n,elem); //将n个elem拷贝赋值给本身。

#include <iostream>
#include <string>
#include <deque>
using namespace std;

void printDeque1(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test02() 
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque1(d1);

	//operator=
	deque<int>d2;
	d2 = d1;
	printDeque1(d2);

	//assign赋值
	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	printDeque1(d3);

	//n个elem的方式
	deque<int>d4;
	d4.assign(10, 100);
	printDeque1(d4);
}

int main()
{
	test02();
	system("pause");
	return 0;
}

3.3.4 deque大小的操作

功能描述：

对deque容器的大小进行操作

函数原型：

1. deque.empty(); //判断容器是否为空

2. deque.size(); //返回容器中元素的个数

3. deque.resize(); //重新指定容器的长度为num, 若容器边长，则以默认值填充新位置。

   1. ​ 如果容器变短，则末尾超出容器长度的元素被删除

      deque.resize(num.elem); //重新指定容器的长度为num,若容器边长，则以elem值填充新的位置。

      ​ //若容器变短，则末尾超出容器长度的元素被删除。

      //deque容器没有容量的概念

3.3.5 deque的插入和删除

函数原型：
两端插入操作：
push_back(elem);			//在容器尾部添加一个数据
push_front(elem);			//在容器头部插入一个数据
pop_back();					//删除容器中最后一个数据
pop_front();				//删除容器第一个数据
指定位置操作：
insert(pop,elem);			//在pos位置插入一个elem元素的拷贝，返回新数据的位置
insert(pos,n,elem);			//在pos位置插入n个elem数据，无返回值
insert(pos,beg,end);		//在pos位置插入[beg,end）区间的数据，无返回值
clear();					//清空容器中的所有数据
erase(beg,end);				//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);					//删除pos位置的数据，并返回下一个数据的位置。

#include <iostream>
#include <string>
#include <deque>
using namespace std;

//deque容器的插入和删除
void printDeque2(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test03() 
{
	deque<int>d1;
	//尾插、头插
	d1.push_back(10);
	d1.push_back(100);
	d1.push_front(20);
	d1.push_front(200);
	printDeque2(d1);
	//头删、尾删
	d1.pop_front();
	d1.pop_back();
	printDeque2(d1);
	//指定位置插入元素
	deque<int>d2;
	d2.push_back(40);
	d2.insert(d2.begin(), 1314);//在d2的头部位置插入元素
	printDeque2(d2);
	d2.insert(d2.begin(), 3, 100);//在d2的头部位置插入3个100
	printDeque2(d2);
	d2.insert(d2.begin(), d1.begin(), d1.end());//在d2的头部插入d1区间的元素
	printDeque2(d2);	
}

void test04() 
{
	deque<int>d1;
	//尾插、头插
	d1.push_back(10);
	d1.push_back(100);
	d1.push_front(20);
	d1.push_front(200);
	printDeque2(d1);
	//进行删除操作  在d1的开头位置进行删除元素
	d1.erase(d1.begin());
	printDeque2(d1);
	d1.erase(d1.begin(), d1.end() - 1);
	printDeque2(d1);
	if (d1.empty())
	{
		cout << "d1为空" << endl;
	}
	else
	{
		cout << "d1不为空" << endl;
	}
}

int main()
{
	//test03();
	test04();
	system("pause");
	return 0;
}

3.3.6 deque数据存取

功能描述：

对deque中的数据的存取操作

函数原型：

at(int idx);		//返回索引idx所指的数据
operator[]; 		//返回索引idx所指的数据
front();			//返回容器中第一个数据元素
back();				//返回容器中最后一个数据元素

#include <iostream>
#include <string>
#include <deque>
using namespace std;



void test05() 
{
	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(30);
	d1.push_back(40);
	d1.push_front(200);
	d1.push_front(100);
	d1.push_front(300);
	d1.push_front(400);

	//遍历输出
	for (int i = 0; i < d1.size(); i++) 
	{
		cout << d1[i] << " ";
	}
	cout << endl;
	//利用at进行遍历输出
	for (int i = 0; i < d1.size(); i++)
	{
		cout << d1.at(i) << " ";
	}
	cout << endl;

	//获取第一个元素和最后一个元素
	cout << "deque的第一个元素为：" << d1.front() << endl;
	cout << "deque的最后一个元素为：" << d1.back() << endl;
}

int main() 
{
	test05();
	system("pause");
	return 0;
}

3.3.7 deque排序

#include <iostream>
#include <string>
#include <deque>
#include <algorithm>
using namespace std;

void printDeque3(const deque<int>& d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test06() 
{
	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_back(50);
	d1.push_back(30);
	d1.push_back(40);
	d1.push_back(100);
	printDeque3(d1);

	//排序  默认排序规则  从小到大  升序
	//对于支持随机访问的迭代器容器，都可以利用sort算法直接对其进行排序。
	sort(d1.begin(), d1.end());
	cout << "排序后：" << endl;
	printDeque3(d1);
}

int main()
{
	test06();
	system("pause");
	return 0;
}

总结：sort算法非常实用，使用时包含头文件algortthm即可

3.4 案例——评委打分

有5名选手：选手ABCDE，10个评委分别对每一名选手打分，取出最高分，取出最低分，取平均

#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <ctime>
#include <algorithm>
using namespace std;

/*有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除最低分，取平均*/

//构建选手类别，用于创建每个选手
class Person 
{
public:
	Person(string name, int score) 
	{
		this->m_name = name;
		this->m_score = score;
	}
	string m_name;
	int m_score;
};

void createPlayer(vector<Person> &v) 
{
	//创建人就需要有人的名字和分数
	string nameSeed = "ABCDE";
	for (int i = 0; i < 5; i++) 
	{
		//姓名
		string name = "选手";
		name += nameSeed[i];
		//分数  先初始化为0
		int score = 0;
		//再用名字和分数初始化人这个对象
		Person p(name, score);
		//放到vector容器中
		v.push_back(p);
	}
}
void setScore(vector<Person>&v) 
{
	//设置分数首先需要拿到人，然后对每个人进行打分
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) 
	{
		  //通过循环遍历就得到了每个人*it，接下来就是对每个人进行打分
		deque<int> d;
		for (int j = 0; j < 10; j++) 
		{
			int score = rand() % 41 + 60;
			d.push_back(score);
		}
		//如果想看一下各个评委对每个人的打分情况可以做下边的测试
		cout << (*it).m_name << "得分为：" << endl;
		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++) 
		{
			cout << *dit << " ";
		}
		cout << endl;
		//然后排序
		sort(d.begin(), d.end());
		//找到最低分和最高分分别去除
		d.pop_back();
		d.pop_front();
		//计算平均分
		int sum = 0;
		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
		{
			sum += *dit;
		}
		int avg = sum / d.size();
		//一个人的平均分算完了，还要更新到这个人的信息中
		(*it).m_score = avg;
	}

}
void showScore(vector<Person>& v) 
{
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) 
	{
		cout << "姓名：" << (*it).m_name << " 分数：" << (*it).m_score << endl;
	}
}
int main() 
{
	//为了让每个选手的每次打分都不台一样，因此这里根据时间引入随机种子
	srand((unsigned int)time(NULL));
	//首先需要创建选手的信息，然后存放在vector容器中
	vector<Person>v;//这一步只是给了容器来存放具体的人，但是人的信息还没有创建
	createPlayer(v);
	//其次需要对每个人进行打分
	setScore(v);
	//设置完成后就需要对这个人的姓名和分数进行显示
	showScore(v);
	system("pause");
	return 0;
}

3.5 stack 容器

3.5.1 stack基本概念

概念：stack是一种先进后出的数据结构，它只有一个出口

栈是不允许有遍历行为的。

栈可以判断容器是否为空

可以返回元素个数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KXjxScIZ-1685672196911)(F:\Desktop\C++\fig\微信图片_20230429150917.png)]

3.5.2 stack常用接口

功能描述： 栈容器常用的对外接口

构造函数：

stack<T> stk;				//stack采用模板类实现，stack对象的默认
stack(const stack &stk);	//拷贝构造函数

赋值操作：
stack &operator=()；  		//重载等号操作
数据存取：
push(elem);					//向栈顶添加元素
pop();						//从栈顶移除第一个元素
top();						//返回栈顶元素
大小操作：
empty();					//判断堆栈是否为空
size();					    //回栈的大小

#include <iostream>
#include <string>
#include <stack>
using namespace std;

//栈stack容器（特点：符合先进后出的数据结构）

void test01() 
{
	//特点：先进后出的数据结构
	stack<int>s;

	//入栈
	s.push(10);
	s.push(20);
	s.push(30);
	s.push(40);
	s.push(50);
	cout << "栈的大小为：" << s.size() << endl;
	//只要栈不为空，就查看栈顶，执行出栈
	while (!s.empty()) 
	{
		//查看栈顶元素
		cout << "栈顶元素为：" << s.top() << endl;

		//出栈
		s.pop();
	}
	cout << "栈的大小为：" << s.size() << endl;
}

int main() 
{
	test01();
	system("pause");
	return 0;
}

3.6 queue容器

3.6.1 queue基本概念

概念：queue是一种先进先出的数据结构，它有两个出口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jq386HuK-1685672196911)(F:\Desktop\C++\fig\微信图片_20230429160614.png)]

队列容器允许从一端新增元素，从另一段移除元素

队列中只有队头和队尾可以被外界使用，因此队列不允许有遍历行为

队列中进数据被成为——入队

队列中出数据被称为——出队

3.6.2常用接口

构造函数：
queue<T> que;				//queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que);	//拷贝构造函数

赋值操作：
queue &operator=(const queue &que)；  		//重载等号操作
数据存取：
push(elem);					//向队尾添加元素
pop();						//从队头移除第一个元素
back();						//返回最后一个元素
front();					//返回第一个元素
大小操作：
empty();					//判断队列是否为空
size();						//返回队列的大小

#include <iostream>
#include <string>
#include <queue>
using namespace std;

class PPerson {
public:
	PPerson(string name, int age) 
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};

void test02() 
{
	//创建队列
	queue<PPerson>q;

	//准备数据
	PPerson p1("唐僧", 30);
	PPerson p2("孙猴子", 35);
	PPerson p3("猪八戒", 60);
	PPerson p4("沙僧", 20);

	//入队
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);
	cout << "队列中元素数目为：" << q.size() << endl;
	while (!q.empty()) //当队列不为空的时候我们查看队列头元素和队尾元素，并执行出队操作
	{
		cout << "队头元素姓名为： " << q.front().m_name << " 年龄： " << q.front().m_age << endl;
		cout << "队尾元素姓名为： " << q.back().m_name << " 年龄： " << q.back().m_age << endl;
		//出队
		q.pop();
	}
	cout << "队列中元素数目为：" << q.size() << endl;
}

int main()
{
	test02();
	system("pause");
	return 0;
}

3.7 list容器

3.7.1 list基本概念

功能：将数据进行链式存储

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

链表的组成：链表由一系列的结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cvEdBukX-1685672196912)(F:\Desktop\C++\fig\微信图片_20230503090304.png)]

链表的优点：可以对任意位置进行快速的插入和删除元素，修改指针即可，不需要移动大量元素。采用动态存储分配，不会造成资源浪费。

缺点：对于链表的遍历（时间）速度没有数组快，需要通过指针域来访问下一个元素。占用的空间（指针域）比数组大。

list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6xzfazHK-1685672196912)(F:\Desktop\C++\fig\微信图片_20230503090938.png)]

总结：STL中List和vector是两个最常被使用的容器，各有优缺点。

3.1.2 List中的构造函数

功能描述：创建List容器

函数原型：

list<T> lst;			//list采用模板类实现对象的默认构造形式
list(beg,end);			//构造函数将（beg,end）区间中的元素拷贝给本身
list(n,elem);			//构造函数将n个elem拷贝给本身
list(const list &lst);	//拷贝构造函数。

#include <iostream>
#include <string>
#include <list>
using namespace std;

void printList(const list<int>& L) 
{
	for (list<int>::const_iterator lit = L.begin(); lit != L.end(); lit++) 
	{
		cout << *lit << " ";
	}
	cout << endl;
}

void test01() 
{
	list<int>L1; //默认构造函数
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	L1.push_back(50);
	printList(L1);
	//区间构造函数
	list<int> L2(L1.begin(),L1.end());
	printList(L2);
	//拷贝构造函数
	list<int>L3(L2);
	printList(L3);
	//n个elem的形式
	list<int>L4(5, 1000);
	printList(L4);
}

int main() 
{
	test01();
	system("pause");
	return 0;
}

3.7.3 list容器的赋值和交换

功能描述：给list容器进行赋值，以及交换list容器

函数原型：

assign(beg,end);
assign(n,elem);
list &operator=(const list &lst); //重载等号运算符
swap(lst);//将list与本身的元素互换。

#include <iostream>
#include <string>
#include <list>
using namespace std;

void printList(const list<int>& L) 
{
	for (list<int>::const_iterator lit = L.begin(); lit != L.end(); lit++) 
	{
		cout << *lit << " ";
	}
	cout << endl;
}

void test01() 
{
	list<int>L1; //默认构造函数
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	L1.push_back(50);
	printList(L1);
	//区间构造函数
	list<int> L2(L1.begin(),L1.end());
	printList(L2);
	//拷贝构造函数
	list<int>L3(L2);
	printList(L3);
	//n个elem的形式
	list<int>L4(5, 1000);
	printList(L4);
}
void test02() 
{
	list<int>L1; //默认构造函数
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	L1.push_back(50);
	//等号赋值
	list<int>L2;
	L2 = L1;
	printList(L2);
	//assign赋值
	list<int>L3;
	L3.assign(L1.begin(), L1.end());
	printList(L3);
	//assign n个elem
	list<int>L4;
	L4.assign(10, 100);
	printList(L4);
}
void test03() 
{
	list<int>L1; //默认构造函数
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	L1.push_back(50);
	//swap函数的使用
	list<int>L2;
	L2.assign(5, 100);
	cout << "交换前：" << endl;
	printList(L1);
	printList(L2);
	cout << "交换后：" << endl;
	L1.swap(L2);
	printList(L1);
	printList(L2);
}
//list容器大小操作
void test04() 
{
	list<int>L1; //默认构造函数
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	L1.push_back(50);
	printList(L1);
	//List函数中的一些操作
	if (L1.empty()) 
	{
		cout << "L1为空：" << endl;
	}
	else 
	{
		cout << "L1不为空：" << endl;
		cout << "L1的size为：" <<L1.size() <<endl;
	}
	//重新指定空间大小
	L1.resize(10,523);
	printList(L1);
	L1.resize(3);
	printList(L1);
}

int main() 
{
	//test01();
	//test02();
	//test03();
	test04();
	system("pause");
	return 0;
}

3.7.5 list的插入和删除

功能描述：对list容器进行数据的插入和删除

函数原型：

push_back(elem);
pop_back();
push_front(elem);
pop_front();
insert(pop,elem);
insert(pos,n,elem);
insert(pos,beg,end);
clear();
erase(beg,end);
erase(pos);
remove(elem);//删除容器中所有与elem值匹配的元素。




void test05()
{
	list<int>L; //默认构造函数
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	//头插
	L.push_front(100);
	L.push_front(200);
	L.push_front(300);
	printList(L);
	//头删除
	L.pop_front();
	printList(L);
	//尾删除
	L.pop_back();
	printList(L);

	//在某个位置插入元素
	list<int>::iterator it = L.begin();
	L.insert(++it, 1000);
	printList(L);
	L.insert(++it, 5, 1000);
	printList(L);
	//删除
	it = L.begin();
	L.erase(++it);
	printList(L);
	//移除
	L.push_back(1000);
	L.push_back(1000);
	L.push_back(1000);
	printList(L);
	L.remove(1000);
	printList(L);
    
    L.clear();
    printList(L);
}

//数据存取
void test06() 
{
	list<int>L; //默认构造函数
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);

	// L[0]  不可以使用[]访问list容器中的元素

	//L1.at(0)   不可以使用at方式访问list容器中的元素。

	//原因是list本质是链表，不是用连续的线性空间存储数据的，迭代器也是不支持随机访问的。
	cout << "第一个元素是：" <<L.front() <<endl;
	cout << "最后一个元素为：" << L.back() << endl;

	//验证迭代器是不支持随机访问的
	list<int>::iterator it = L.begin();

	it++;//支持双向
	//it = it + 1;  //不支持随机访问
}

3.7.7 list的反转个排序

功能描述：将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

reverse(); //反转链表

sort(); //链表排序

//list的反转和排序
bool mycompare(int v1, int v2)
{
	return v1 > v2;
}
void test07() 
{
	list<int>L; //默认构造函数
	L.push_back(10);
	L.push_back(50);
	L.push_back(30);
	L.push_back(3);
	cout << "反转前容器：" << endl;
	printList(L);
	//容器反转
	cout << "反转后容器：" << endl;
	L.reverse();
	printList(L);
	//容器排序
	cout << "排序前：" << endl;
	printList(L);
	//所有不支持随机访问迭代器的容器，不可以使用标准算法
	//不支持随机访问迭代器的容器，内部会提供对应的一些算法
	//sort(L.begin(),L.end());
	L.sort(); //默认排序规则是升序的
	//排序后
	cout << "排序后：" << endl;
	printList(L);
	//想要实现排序是以降序的方式实现的。
	L.sort(mycompare);
	printList(L);

}

3.7.8 排序案例

案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高

排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序

#include <iostream>
#include <string>
#include <list>
using namespace std;
class Person 
{
public:
	Person(string name, int age, int height) 
	{
		this->m_name = name;
		this->m_age = age;
		this->m_height = height;
	}
	string m_name;
	int m_age;
	int m_height;
};
void printListPerson(list<Person>& p) 
{
	for (list<Person>::iterator it = p.begin(); it != p.end(); it++)
	{
		cout << "姓名：" << (*it).m_name << " 年龄：" << (*it).m_age << " 身高：" << (*it).m_height << endl;
	}
}
bool comparePerson(Person &p1, Person &p2) 
{
	if (p1.m_age == p2.m_age) 
	{
		return p1.m_height > p2.m_height;
	}
	else 
	{
		return p1.m_age < p2.m_age;
	}
	
}
void test08() 
{
	list<Person> L;
	Person p1("赵康", 25, 183);
	Person p2("谢乐成", 25, 175);
	Person p3("付漫侠", 25, 165);
	Person p4("张颖", 26, 173);
	Person p5("张强", 25, 176);
	cout << "排序前：" << endl;
	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	printListPerson(L);

	//排序
	cout << "排序后：" << endl;
	L.sort(comparePerson);
	//printListPerson(L);
	for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
	{
		cout << "姓名：" << (*it).m_name << " 年龄：" << (*it).m_age << " 身高：" << (*it).m_height << endl;
	}
}
int main()
{
	test08();
	system("pause");
	return 0;
}

3.8 set/multiset 容器

基本概念：所有元素都会在插入时自动被排序

本质：set/multiset 属于关联式容器，底层结构是用二叉树实现的。

set/multiset 区别：

1. set 不允许容器中有重复的元素，
2. multiset允许容器中有重复的元素。

3.8.2 set构造和赋值

构造
set<T> st;						//默认构造函数
set(const set &st);				//拷贝构造函数
赋值
set &operator=(const set &st);	//重载等号操作符

#include <iostream>
#include <string>
#include <set>
using namespace std;

void printSet(const set<int> &s) 
{
	for (set<int>::const_iterator sit = s.begin(); sit != s.end(); sit++) 
	{
		cout << *sit << " ";
	}
	cout << endl;
}

void test01() 
{
	set<int>s1;
	
	//set容器中插入元素用的是insert语法,插入容器时会自动排序，并且元素不显示重复的。
	s1.insert(10);
	s1.insert(20);
	s1.insert(10);
	s1.insert(30);
	s1.insert(10);
	s1.insert(30);

	printSet(s1);

	//拷贝构造函数
	set<int>s2(s1);
	printSet(s2);

	//赋值
	set<int>s3;
	s3 = s2;
	printSet(s3);
	
}
//set大小和交换

void test02() 
{
	set<int>s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(10);
	s1.insert(30);
	printSet(s1);

	//判断容器是否为空
	if (s1.empty()) 
	{
		cout << "s1为空." << endl;
	}
	else 
	{
		cout << "s1不为空：" << endl;
		cout << "s1的大小为：" << s1.size() << endl;
	}
}

void test03() 
{
	//容器1
	set<int>s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(10);
	s1.insert(30);
	
	//容器2
	set<int>s2;
	s2.insert(1);
	s2.insert(20);
	s2.insert(8);
	s2.insert(30);
	cout << "交换前：" << endl;
	printSet(s1);
	printSet(s2);

	s1.swap(s2);
	cout << "交换后：" << endl;
	printSet(s1);
	printSet(s2);

}
//set容器的插入和删除
/*insert(elem);			//在容器中插入元素  
clear();				//清除所有元素
erase(pos);				//删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg,end);			//删除区间[beg,end)的所有元素，返回下一个元素的迭代器
erase(elem);			//删除容器中值为elem的元素。
*/
//插入和删除
void test04() 
{
	set<int>s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(10);
	s1.insert(30);
	printSet(s1);

	s1.erase(10);
	printSet(s1);

	s1.erase(s1.begin());
	printSet(s1);

	//清空
	//s1.erase(s1.begin(), s1.end());
	s1.clear();
	printSet(s1);

}
//set容器的查找和统计
//find(key);  //不管能否查到最终返回的都是一个迭代器
//count(key);
void printmultiSet(const multiset<int>& s) 
{
	for (multiset<int>::const_iterator mit = s.begin(); mit != s.end(); mit++) 
	{
		cout << *mit << endl;
	}
	cout << endl;
}
void test05() 
{
	multiset<int>s1;
	s1.insert(10);  //对于该插入会返回对组的数据类型  pair<set<int>::iterator,bool> ret = s1.insert(10);
	s1.insert(20);
	s1.insert(10);
	s1.insert(30);
	printmultiSet(s1);
	//查找元素
	set<int>::iterator pos = s1.find(30);
	cout << "查找元素：" << endl;
	if (pos != s1.end())
	{
		cout << "找到元素：" << endl;
	}
	else 
	{
		cout << "未找到元素：" << endl;
	}
	
	//统计个数
	int num = s1.count(10);
	cout << "统计数字10的个数为：" << endl;
	cout << "num = " << num << endl;
}
//对组的两种创建方式
// 成对出现的数据，利用对组可以返回两个数据
//pair<type, type> p(value1, value2);  
//pair<type, type> p = make_pair(value1, value2);

void test06() 
{
	//第一种方式
	pair<string, int>p("Tom", 20);

	cout << "姓名：" << p.first << " 年龄：" << p.second << endl;

	pair<string, int>p2 = make_pair("Jerry", 30);
	cout << "姓名：" << p2.first << " 年龄：" << p2.second << endl;
}
//set容器的排序规则
//仿函数：返回值是bool类型，重载的符号是()，才称之为仿函数

int main01() 
{
	//test01();
	//test02();
	//test03();
	//test04();
	//test05();
	test06();
	system("pause");
	return 0;
}

#include <iostream>
#include <string>
#include <set>
#define _CRT_SECURE_NO_WARNINGS
using namespace std;

class Mycompare
{
public:
	bool operator()(int a, int b) const
	{
		return a > b;
	}

};
void test07()
{
	set<int, Mycompare>s5;

	s5.insert(20);  //set<int,Mycompare>的instance具有const属性，因此在仿函数后边需要加上const
	s5.insert(10);
	s5.insert(30);

	for (set<int, Mycompare>::iterator sit = s5.begin(); sit != s5.end(); sit++)
	{
		cout << *sit << " ";
	}
	cout << endl;
}
//set容器中存放自定义数据类型
class Person {
public:
	Person(string name, int age) {
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};
class ComparePerson 
{
public:
	bool operator()(const Person &p1, const Person &p2) const
	{
		return p1.m_age > p2.m_age;
	}
};
void test08() 
{
	set<Person, ComparePerson> s;
	Person p1("刘备", 24);
	Person p2("张飞", 20);
	Person p3("关羽", 26);
	Person p4("项羽", 19);

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);
	for (set<Person, ComparePerson>::iterator pit = s.begin(); pit != s.end(); pit++) 
	{
		cout << "姓名：" << (*pit).m_name << " 年龄:" << (*pit).m_age << endl;
	}
}

int main()
{
	//test07();
	test08();
	system("pause");
	return 0;
}

3.9 map/multimap容器

3.9.1 map基本概念

简介：

1. map中所有元素都是pair
2. pair中第一个元素为key（键值），起到索引的作用，第二个元素为value（实值）
3. 所有元素都会根据元素的键值自动排序

本质：

1. map/multimap属于关联式容器，底层结构是用二叉树实现的

优点：

1. 可以根据key值快速找到value值

map和multimap的区别

1. map不匀速容器中有重复的key元素
2. multimap允许容器中有重复的key值元素

3.9.2 map构造和赋值

#include <iostream>
#include <string>
#include <map>
using namespace std;

void printMap(map<int,int> &m) 
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) 
	{
		cout << "第一个元素为：" << (*it).first << "第二个元素为：" << (*it).second << endl;
	}
	cout << endl;
}

//map容器 构造和赋值
void test01() 
{
	//创建map容器,注意map容器中的模板参数列表是需要传入两个参数类型的
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));  //map容器中插入时，需要插入 键值对，第一个元素是索引，第二个是数据
	m.insert(pair<int, int>(5, 50));  //插入排序是默认根据key排序
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(8, 30));

	printMap(m);
	map<int, int>m1(m);
	printMap(m1);

	//赋值
	map<int, int>m2;
	m2 = m1;
	printMap(m2);

}
//map容器的大小操作
void test02(){
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(8, 30));
	m.insert(pair<int, int>(3, 20));
	m.insert(pair<int, int>(5, 30));
	
	//判断是否为空
	if (m.empty()) 
	{
		cout << "map容器为空" << endl;
	}
	else 
	{
		cout << "map容器不为空" << endl;
		cout << "map容器的大小为：" << m.size() << endl;
	}
}
//交换
void test03() 
{
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(8, 30));
	m.insert(pair<int, int>(3, 20));
	m.insert(pair<int, int>(5, 30));

	map<int, int>m1;
	m1.insert(pair<int, int>(1, 10));
	m1.insert(pair<int, int>(4, 30));
	m1.insert(pair<int, int>(6, 30));
	m1.insert(pair<int, int>(4, 20));
	m1.insert(pair<int, int>(5, 30));
	cout << "交换前打印输出：" << endl;
	printMap(m);
	printMap(m1);
	cout << "交换后打印输出：" << endl;
	m.swap(m1);
	printMap(m);
	printMap(m1);
}
//map容器的插入和删除
void test04() 
{
	map<int, int>m;
	//在容器中插入元素
	//第一种方式
	m.insert(pair<int, int>(1, 10));  
	//第二种方式
	m.insert(make_pair(5, 50));  
	//第三种方式
	m.insert(map<int, int>::value_type(2, 20)); //map作用域下的值类型
	//第四种利用中括号的方式插入
	m[4] = 50;//不建议使用这种方式插入
	//[]可以用key来访问value
	cout << m[5] << endl;
	m.insert(pair<int, int>(8, 30));
	printMap(m);

	//删除元素
	m.erase(1); //删除容器中值为key的元素
	printMap(m);
	m.erase(m.begin()); //删除容器中开始位置的元素
	printMap(m);

	//清空
	//m.erase(m.begin(), m.end());//删除区间元素
	m.clear();
	printMap(m);
	

}
//map容器中的查找和统计数据
void test05() 
{
	//查找
	map<int, int>m;
	//在容器中插入元素
	//第一种方式
	m.insert(pair<int, int>(1, 10));
	//第二种方式
	m.insert(make_pair(5, 50));
	//第三种方式
	m.insert(map<int, int>::value_type(2, 20)); //map作用域下的值类型

	map<int,int>::iterator pos = m.find(5);  //查找元素后返回的是一个迭代器，因此用map迭代器来接收
	if (pos != m.end())
	{
		cout << "查找到该元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
	}
	else 
	{
		cout << "未找到该元素：" << endl;
	}
	//统计
	//map不允许插入重复的key元素，count统计而言  结果要么是0，要么是1
	//multimap的count统计可能大于1
	int num = m.count(5);
	cout << "num = " << num << endl;

}
int main01() 
{
	//test01();
	//test02();
	//test04();
	test05();
	system("pause");
	return 0;
}

#include <iostream>
#include <string>
#include <map>
using namespace std;



class mycompare 
{
public:
	bool operator()(int v1, int v2) const
	{
		return v1 > v2;
	}
};

void printmap1(map<int, int, mycompare>& m)
{
	for (map<int, int, mycompare>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "第一个元素为：" << (*it).first << "第二个元素为：" << (*it).second << endl;
	}
	cout << endl;
}

//map容器  排序
void test08() 
{
	map<int, int,mycompare>m;
	m.insert(make_pair(1, 10));
	m.insert(make_pair(14, 10));
	m.insert(make_pair(5, 50));
	m.insert(make_pair(6, 80));
	m.insert(make_pair(8, 10));

	for (map<int, int, mycompare>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "第一个元素为：" << (*it).first << " 第二个元素为：" << (*it).second << endl;
	}
	cout << endl;
}

int main() 
{
	test08();
	system("pause");
	return 0;
}

3.10 员工分组

3.10.1 案例描述

1. 公司今天招聘了10名员工，进入公司后需要指派在那个部门工作
2. 员工信息：姓名 工资组成；部门分为：策划、美术、研发
3. 随机给10名员工分配部门和工资
4. 通过multimap进行信息的插入 key（部门编号）value(员工)
5. 分部门显示员工信息

3.10.2 实现步骤

1. 创建10名员工，放到vector容器中
2. 遍历vector容器，取出每个员工，进行随机分组
3. 分组后，将员工部门编号作为key，具体员工作为value，放到multimap容器中
4. 分部门显示员工信息

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <ctime>

using namespace std;
#define CEHUA 0
#define MEISHU 1
#define YANFA 2
/*
1. 公司今天招聘了10名员工，进入公司后需要指派在那个部门工作
2. 员工信息：姓名    工资组成；部门分为：策划、美术、研发
3. 随机给10名员工分配部门和工资
4. 通过multimap进行信息的插入  key（部门编号）value(员工)
5. 分部门显示员工信息
*/
class Worker {
public:
	string m_name;
	int m_salary;
};

void createWorker(vector<Worker>& v) {
	string nameSeed = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++) 
	{
		//创建员工
		Worker worker;
		worker.m_name = "员工";
		worker.m_name += nameSeed[i];

		worker.m_salary = rand() % 10000 + 10000;

		//将员工放入vector容器中
		v.push_back(worker);
	}
}

void setGroupWorker(vector<Worker> &v,multimap<int, Worker>&m) 
{
	for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++) 
	{
		//遍历vector容器中的员工，随机产生部门编号
		int Did = rand() % 3; //0  1  2
		//将员工插入到multimap容器中
		//key代表部门编号，value代表具体的员工
		m.insert(make_pair(Did, *it));
	}
}
//分组展示
void showGroupWorkerInfo(multimap<int, Worker>&m) 
{
	//按照部门显示员工信息
	//0 A B C, 1 D E F, 2 H I J K
	cout << "策划部门:" << endl;
	
	multimap<int, Worker>::iterator pos = m.find(CEHUA); //先找到策划部门的初始位置
	int count = m.count(CEHUA);//统计具体人数
	int index = 0;
	for (; pos != m.end() && index < count; pos++, index++) //起始位置不需要
	{
		cout << "姓名：" << pos->second.m_name << "工资：" << pos->second.m_salary << endl;
	}
	cout << "-------------------------" << endl;
	cout << "美术部门:" << endl;

	pos = m.find(MEISHU); //先找到策划部门的初始位置
	count = m.count(MEISHU);//统计具体人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++) //起始位置不需要
	{
		cout << "姓名：" << pos->second.m_name << "工资：" << pos->second.m_salary << endl;
	}
	cout << "-------------------------" << endl;
	cout << "研发部门:" << endl;

	pos = m.find(YANFA); //先找到策划部门的初始位置
	count = m.count(YANFA);//统计具体人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++) //起始位置不需要
	{
		cout << "姓名：" << pos->second.m_name << "工资：" << pos->second.m_salary << endl;
	}


}
int main() 
{
	srand((unsigned int)time(NULL));
	//1.创建员工，并放入vector容器中
	vector<Worker> vWorker;
	createWorker(vWorker);

	//测试
	//for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); it++) 
	//{
	//	cout << "姓名：" << (*it).m_name << " 工资：" << (*it).m_salary << endl;
	//}


	//2.将员工进行分组
	multimap<int, Worker>mworker;
	setGroupWorker(vWorker, mworker);//第一个变量是具体的员工，第二个变量是放到这个容器中
	//3.展示员工信息
	showGroupWorkerInfo(mworker);
	system("pause");
	return 0;
}

关于分组展示员工信息的过程是值得反复回顾的，因为这里涉及到for循环最终的结束标准，以及开始标准。

4. STL-函数对象

4.1 函数对象

4.1.1 函数对象概念

1. 重载函数调用操作符的类，其对象称为函数对象。
2. 函数对象使用重载的（）时，行为类似函数调用，也叫仿函数。

本质：

函数对象（仿函数）是一个类，不是一个函数

4.1.2函数对象使用

特点：

函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值

函数对象超出普通函数的概念，函数对象可以有自己的状态

函数对象可以作为参数传递

#include <iostream>
#include <string>
#include <ctime>
using namespace std;

class MyAdd {
public:
	int operator()(int v1,int v2) 
	{
		return v1 + v2;
	}
};
//1.函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
void test01() 
{
	MyAdd myadd;
	cout<<myadd(10, 10) << endl;
}
//2.函数对象超出普通函数的概念，函数对象可以有自己的状态。
class MyPrint 
{
public:
	MyPrint() {
		this->count = 0;
	}
	void operator()(string test) 
	{
		cout << test << endl;
		this->count++;
	}
	int count;
};
void test02() 
{
	MyPrint myprint;
	myprint("hello world!");
	myprint("hello world!");
	myprint("hello world!");
	myprint("hello world!");

	cout << "myprint调用的次数为：" << myprint.count << endl;
}
//3.函数对象可以作为参数传递
void doPrint(MyPrint& mp, string test) 
{
	mp(test);
}

void test03() 
{
	MyPrint myprint;
	doPrint(myprint, "Hello C++!");
}

int main() 
{
	test03();
	system("pause");
	return 0;
}

总结：

​ 仿函数写法非常灵活，可以作为函数参数进行传递。

4.2 谓词

4.2.1 谓词概念

概念：

1. 返回bool类型的 仿函数称为谓词
2. 如果operator（）接受一个参数，那么叫做一元谓词
3. 如果operator（）接受两个参数，那么叫做二元谓词

4.2.2 一元谓词 和二元谓词

#include <iostream>
#include <string>
#include <ctime>
#include <vector>
#include <algorithm>
using namespace std;

//仿函数  返回值类型时bool数据类型，称为谓词,参数为1个表明是一元谓词
//一元谓词  
class GreaterFive {
public:
	bool operator()(int val) {
		return val > 5;
	}
};
void test04() 
{
	vector<int>v;
	for (int i = 0; i < 10; i++) 
	{
		v.push_back(i);
	}
	//查找容器中有没有大于5的数字
	//GreaterFive() 匿名函数对象
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end()) 
	{
		cout << "未找到" << endl;

	}
	else 
	{
		cout << "找到了大于5 的数字" <<*it<< endl;
	}

}
//二元谓词
class MyCompare 
{
public:
	bool operator()(int v1, int v2) {
		return v1 > v2;
	}
};
void test05() 
{
	vector<int>v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(50);
	v.push_back(40);

	sort(v.begin(), v.end());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) 
	{
		cout << *it << " ";
	}
	cout << endl;

	//使用函数对象， 改变算法策略，变为排序规则为从大到小
	cout << "----------------------------" << endl;
	sort(v.begin(), v.end(), MyCompare());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
int main()
{
	test05();
	system("pause");
	return 0;
}

4.3 内建的函数对象

4.3.1内建函数对象意义

概念：STL内建了一些函数对象

分类：算术仿函数、关系仿函数、逻辑仿函数

用法：这些仿函数所产生的对象，用法和一般函数完全相同

​ 使用内建函数对象，需要引入头文件 functional

4.3.2算数仿函数

功能描述：

1. 实现四则运算
2. 其中negate是一元运算，其他都是二元运算

仿函数原型：

template<class T> T plus<T>				//加法仿函数
template<class T> T minus<T>			//减法仿函数
template<class T> T multiplies<T>		//乘法仿函数
template<class T> T divides<T>			//除法仿函数
template<class T> T modulus<T>			//取模仿函数
template<class T> T negate<T>			//取反仿函数

#include <iostream>
#include <string>
#include <functional>  //内建函数对象头文件
using namespace std;

//内建函数对象  算术仿函数

//negate 一元仿函数  取反仿函数

void test06() 
{
	negate<int>n;

	cout << n(50) << endl;
}

//plus 二元仿函数  加法
void test07() 
{
	plus<int>p;
	cout << p(10, 20) << endl;
}
int main() 
{
	test07();
	system("pause");
	return 0;
}

4.3.3 关系仿函数

功能描述：

​ 实现关系对比

仿函数原型

template<class T> bool equal_to<T>				//等于
template<class T> bool not_equal_to<T>			//不等于
template<class T> bool greater<T>				//大于
template<class T> bool greater_equal<T>			//大于等于
template<class T> bool less<T>					//小于
template<class T> bool less_equal<T>			//小于等于

4.3.4 逻辑仿函数（实际上基本上是用不到的）

功能描述：

1. 实现逻辑运算

函数原型：

template<class T> bool logical_and<T>		//逻辑与
template<class T> bool logical_or<T>		//逻辑或
template<class T> bool logical_not<T>		//逻辑非

#include <iostream>
#include <string>
#include <cmath>
#include <vector>
#include <functional>
#include <algorithm>
using namespace std;

//内建函数对象_逻辑仿函数
//逻辑非  logical_not

void test09() 
{
	vector<bool>v;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	for (vector<bool>::iterator it = v.begin(); it != v.end(); it++) 
	{
		cout << *it << " ";
	}
	cout << endl;

	//利用逻辑非 将容器v 搬运到 容器v2中，并执行取反的操作, 
	//必须先进行搬运，才能操作，不能直接取反。
	vector<bool>v2;
	v2.resize(v.size());

	transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
	for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main() 
{
	test09();
	system("pause");
	return 0;
}

5. STL-常用算法

概述：

1. 算法主要是由头文件

   <algorithm> <functional><numeric>组成
   <algorithm> 是所有STL头文件中最大的一个,范围涉及到比较 交换 查找.遍历.复制.修改等等
   <numeric>体积很小,只包括几个在序列上面进行简单数学运算的模板函数
   <functional>定义了一些模板类,用以声明函数对象.
   

   5.1 常用的遍历算法

   算法简介: for_each //遍历容器

   ​ transform //搬运容器到另一个容器中

   5.1.1 for_each

   功能描述:

   ​ 实现遍历容器

   函数原型:

   for_each(iterator beg, iterator end, _func);

   ​ //遍历算法 遍历容器元素

   ​ //beg 开始迭代器

   ​ //end 结束迭代器

   ​ //_func 函数或者函数对象

   5.2 常用查找算法

   算法简介:

   find //查找元素

   find_if //按条件查找元素

   adjacent_find //查找相邻重复元素

   binary_search //二分查找法

   count //统计元素个数

   count_if //按条件统计元素个数

   5.2.1 find

   查找指定元素,找到返回指定元素的迭代器,找不到返回结束迭代器end()

   函数原型:

   find(iterator beg,iterator end, value);
   //按值查找元素,找到返回指定值位置的迭代器,找不到返回结束迭代器位置
   //beg 开始迭代器
   //end 结束迭代器
   //value 查找的元素
   find_if(iterator beg,iterator end,_Pred);
   //按值查找元素,找到返回指定位置迭代器,找不到返回结束迭代器位置
   //beg 开始迭代器
   //end 结束迭代器
   //_Pred 函数或者谓词(返回bool类型的仿函数)
   adjacent_find(iterator beg, iterator end);
   //查找相邻重复元素，返回相邻元素的第一个位置的迭代器
   //beg 开始迭代器
   //end 结束迭代器
   //总结：面试题中如果出现了查找相邻重复元素，记得用STL中的adjacent_find算法
   bool binary_search(iterator beg,iterator end,value);
   //查找指定元素，查到  返回true，否则返回false
   //注意：在无序序列中不可用
   //beg 开始迭代器
   //end  结束迭代器
   //value 查找的元素
   count(iterator beg,iterator end,value);
   //统计元素出现的次数
   //beg开始迭代器
   //end结束迭代器
   //value统计的元素
   count_if(iterator beg,iterator end, _Pred);
   //按条件统计元素出现次数
   //beg开始迭代器
   //end 结束迭代器
   //_Pred 谓词
   
   

   #include <iostream>
   #include <string>
   #include <vector>
   #include <algorithm>
   using namespace std;
   //查找  find的用法
   void test03() 
   {
   	vector<int>v1;
   	for (int i = 0; i < 10; i++) {
   		v1.push_back(i);
   	}
   	vector<int>::iterator vit = find(v1.begin(), v1.end(), 5);
   	if (vit == v1.end()) 
   	{
   		cout << "没有找到" << endl;
   	}
   	else 
   	{
   		cout << "找到了: " << *vit << endl;
   	}
   	
   }
   class person {
   public:
   	person(string name, int age) 
   	{
   		this->m_name = name;
   		this->m_age = age;
   	}
   	//重载==号
   	bool operator==(const person &p) 
   	{
   		if (m_name == p.m_name && m_age == p.m_age) { return true; }
   		else { return false; }
   	}
   	string m_name;
   	int m_age;
   	
   };
   void test04() 
   {
   	vector<person>vp;
   	person p1("aaa", 25);
   	person p2("bbb", 20);
   	person p3("ccc", 23);
   	person p4("ddd", 21);
   	person p5("eee", 28);
   	//插入到容器中
   	vp.push_back(p1);
   	vp.push_back(p2);
   	vp.push_back(p3);
   	vp.push_back(p4);
   	vp.push_back(p5);
   	//查找
   	vector<person>::iterator it = find(vp.begin(), vp.end(), p2);
   	if (it == vp.end()) 
   	{
   		cout << "没有找到。" << endl;
   	}
   	else 
   	{
   		cout << "找到person元素  姓名：" << it->m_name << " 年龄：" << it->m_age << endl;
   	}
   }
   class Greatefive 
   {
   public:
   	bool operator()(int val) 
   	{
   		return val > 5;
   	}
   };
   //常用查找算法find_if
   //1.查找内置数据类型
   void test05() 
   {
   	vector<int>v;
   	for (int i = 0; i < 10; i++) 
   	{
   		v.push_back(i);
   	}
   	vector<int>::iterator it = find_if(v.begin(), v.end(), Greatefive());
   	if (it == v.end()) 
   	{
   		cout << "没有找到：" << endl;
   	}
   	else 
   	{
   		cout << "找到了大于5的数字：" <<*it<< endl;
   	}
   }
   //2.自定义数据类型
   class Greate25 
   {
   public:
   	bool operator()(const person& p) 
   	{
   		return p.m_age > 25;
   	}
   
   };
   void test06() 
   {
   	vector<person>v;
   
   	person p1("aaa", 25);
   	person p2("bbb", 20);
   	person p3("ccc", 23);
   	person p4("ddd", 21);
   	person p5("eee", 28);
   
   	v.push_back(p1);
   	v.push_back(p2);
   	v.push_back(p3);
   	v.push_back(p4);
   	v.push_back(p5);
   	//查找
   	vector<person>::iterator it = find_if(v.begin(), v.end(), Greate25());
   	if (it == v.end())
   	{
   		cout << "没有找到。" << endl;
   	}
   	else
   	{
   		cout << "找到了年龄大于25的人  姓名：" << (*it).m_name<<" 年龄："<<(*it).m_age << endl;
   	}
   }
   void test07() 
   {
   	vector<int>v;
   	v.push_back(0);
   	v.push_back(1);
   	v.push_back(0);
   	v.push_back(0);
   	
   	vector<int>::iterator pos = adjacent_find(v.begin(), v.end());
   
   	if (pos == v.end()) 
   	{
   		cout << "未找到相邻重复元素" << endl;
   	}
   	else 
   	{
   		cout << "找到相邻重复元素" << *pos<<endl;
   	}
   }
   //binary_search 查找算法  
   void test08() 
   {
   	vector<int>v;
   	for (int i = 0; i < 10; i++) 
   	{
   		v.push_back(i);
   	}
   	//v.push_back; 如果是无序序列，结果未知！
   	//查找容器中是否有9这个元素
   	//注意：容器必须是有序的序列
   	bool ret = binary_search(v.begin(), v.end(),9);
   	if (ret) 
   	{
   		cout << "找到该元素" << endl;
   	}
   	else 
   	{
   		cout << "未找到该元素" << endl;
   	}
   }
   //count
   //1.统计内置数据类型
   void test09() 
   {
   	vector<int>v;
   	v.push_back(10);
   	v.push_back(10);
   	v.push_back(20);
   	v.push_back(10);
   	v.push_back(40);
   	int num = count(v.begin(), v.end(), 10);
   	cout << "num = " << num << endl;
   }
   //2.统计自定义数据类型
   class pperson {
   public:
   	pperson(string name, int age)
   	{
   		this->m_name = name;
   		this->m_age = age;
   	}
   	//重载==号
   	bool operator==(const pperson& p)
   	{
   		if (m_age == p.m_age) { return true; }
   		else { return false; }
   	}
   	string m_name;
   	int m_age;
   
   };
   void test11() 
   {
   	vector<pperson>v1;
   	pperson p1("dad", 25);
   	pperson p2("dafdsa", 25);
   	pperson p3("dadrtre", 23);
   	pperson p4("fd", 25);
   	pperson p5("dafd", 24);
   
   	pperson p("dafdgfj", 25);
   	v1.push_back(p1);
   	v1.push_back(p2);
   	v1.push_back(p3);
   	v1.push_back(p4);
   	v1.push_back(p5);
   	int num = count(v1.begin(), v1.end(), p);
   	cout << "年龄和p年龄一样的人有" << num << "个" << endl;
   }
   //统计内置数据类型
   class Greater20 {
   public:
   	bool operator()(int val) { return val > 20; }
   };
   void test12() 
   {
   	vector<int>v;
   	v.push_back(20);
   	v.push_back(30);
   	v.push_back(40);
   	v.push_back(10);
   	v.push_back(50);
   
   	int num = count_if(v.begin(), v.end(), Greater20());
   	cout << "大于20的元素个数为：" << num << endl;
   }
   //统计自定义数据类型
   class AgeGreater20 
   {
   public:
   	bool operator()(const person& p) 
   	{
   		return p.m_age > 20;
   	}
   };
   void test13() 
   {
   	vector<person>pv;
   	person p1("刘备", 35);
   	person p2("张飞", 35);
   	person p3("关羽", 35);
   	person p4("赵云", 65);
   	person p5("曹操", 45);
   
   	pv.push_back(p1);
   	pv.push_back(p2);
   	pv.push_back(p3);
   	pv.push_back(p4);
   	pv.push_back(p5);
   
   	//统计大于20岁的人员个数
   	int num = count_if(pv.begin(), pv.end(), AgeGreater20());
   	cout << "年龄大于20岁的人的个数为：" << num << endl;
   }
   int main()
   {
   	//test03();
   	//test04();
   	//test05();
   	//test06();
   	//test07();
   	//test08();
   	//test09();
   	//test11();
   	//test12();
   	test13();
   	system("pause");
   	return 0;
   }
   

   5.3常用排序算法

   1. 掌握常用的排序算法

算法简介：

1. sort 				//对容器内元素进行排序
   random_shuffle		//洗牌  指定范围内的元素随机调整次序
   merge				//容器元素合并，并存储在另一个容器中
   reverse				//反转指定范围内的元素
   

   #include <iostream>
   #include <string>
   #include <vector>
   #include <algorithm>
   #include <functional>
   using namespace std;
   
   void myPrint(int val) { cout << val << " "; }
   
   void test01() 
   {
   	vector<int>v;
   
   	v.push_back(10);
   	v.push_back(20);
   	v.push_back(40);
   	v.push_back(30);
   	v.push_back(50);
   
   	//sort默认从小到大排序
   	sort(v.begin(), v.end());
   	for_each(v.begin(), v.end(), myPrint);
   	cout << endl;
   
   	从大到小排序,降序
   	//sort(v.begin(), v.end(), greater<int>());
   	//for_each(v.begin(), v.end(), myPrint);
   	//cout << endl;
   
   	cout << "------random_shuffle算法------" << endl;
   	vector<int>v1;
   	for (int i = 0; i < 10; i++) 
   	{
   		v1.push_back(i);
   	}
   	//利用洗牌 算法 打乱顺序
   	random_shuffle(v1.begin(), v1.end());
   	for_each(v1.begin(), v1.end(), myPrint);
   	cout << endl;
   	cout << "---------merge算法---------" << endl;
   	//merge算法在使用时必须要求两个序列是有序的，并且要么都是升序，要么都是降序。
   	vector<int>v2;
   	for (int i = 0; i < 10; i++)
   	{
   		v2.push_back(i+1);
   	}
   	sort(v2.begin(), v2.end());
   	//利用merge进行合并时，需要先给出目标容器并分配好空间大小
   	vector<int>vTarget;
   	vTarget.resize(v.size() + v2.size());
   
   	merge(v.begin(), v.end(), v2.begin(), v2.end(),vTarget.begin());
   	for_each(vTarget.begin(), vTarget.end(), myPrint);
   	cout << endl;
   	cout << "---------reverse算法---------" << endl;
   	cout << "反转前：" << endl;
   	for_each(v.begin(), v.end(), myPrint);
   	cout << endl;
   	cout << "反转后：" << endl;
   	reverse(v.begin(), v.end());
   	for_each(v.begin(), v.end(), myPrint);
   	cout << endl;
   }
   
   int main() 
   {
   	srand((unsigned int)time(NULL));
   	test01();
   	system("pause");
   	return 0;
   }
   

   5.4 常用的拷贝和替换算法

   算法简介：

   copy			//容器内指定范围的元素拷贝到另一个容器中
   replace			//将容器内指定范围的就元素修改为新元素
       replace(iterator beg,iterator end,oldvalue,newvalue)
   replace_if		//容器内指定范围满足条件的元素替换为新元素
       replace_if(iterator beg,iterator end, _pred,newValue);  //_pred表示谓词。
   swap			//互换两个容器的元素
       swap(container c1,container c2);  //互换两个容器里的元素，两个容器分别是c1和c2。
   

   replace_if按条件查找，可以利用仿函数令狐筛选满足的条件

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

class Myprint {
public:
	void operator()(int val) 
	{
		cout << val << " ";
	}
};
//用于创建一个谓词
class Greater30 
{
public:
	bool operator()(int val) 
	{
		return val > 30;
	}
};
void myPrint01(int val) 
{
	cout << val << " ";
}

void test02() 
{
	vector<int>v2;
	for (int i = 0; i < 10; i++) 
	{
		v2.push_back(i);
	}
	vector<int>v;
	v.resize(v2.size());
	copy(v2.begin(), v2.end(), v.begin());

	for_each(v.begin(), v.end(), myPrint01); //第三个参数可以是函数，也可以是仿函数。
	cout << endl;
	cout << "----------replace算法----------" << endl;
	vector<int>v3;
	v3.push_back(50);
	v3.push_back(200);
	v3.push_back(50);
	v3.push_back(30);

	cout << "替换前：" << endl;
	for_each(v3.begin(), v3.end(), myPrint01);//传入函数的话就传入函数名，传入仿函数的话就传入类的匿名对象
	cout << endl;
	cout << "替换后：" << endl;
	replace(v3.begin(), v3.end(), 50, 500);//这个替换操作会把区间中的所有的旧值50替换成新值500；
	for_each(v3.begin(), v3.end(), myPrint01);
	cout << endl;
	cout << "----------replace_if算法----------" << endl;
	vector<int>v4;
	v4.push_back(500);
	v4.push_back(200);
	v4.push_back(50);
	v4.push_back(30);
	v4.push_back(20);
	v4.push_back(10);
	v4.push_back(15);
	cout << "替换前：" << endl;
	for_each(v4.begin(), v4.end(), Myprint());//传入仿函数的话就传入类的匿名对象,这里传入的是仿函数。
	cout << endl;
	cout << "替换后：" << endl;
	replace_if(v4.begin(), v4.end(), Greater30(), 3000);
	for_each(v4.begin(), v4.end(), Myprint());//传入仿函数的话就传入类的匿名对象,这里传入的是仿函数。
	cout << endl;
	cout << "----------swap算法----------" << endl;
	cout << "替换前：" << endl;
	for_each(v4.begin(), v4.end(), Myprint());//传入仿函数的话就传入类的匿名对象,这里传入的是仿函数。
	cout << endl;
	for_each(v3.begin(), v3.end(), Myprint());
	cout << endl;
	cout << endl;
	cout << "替换后：" << endl;
	swap(v4, v3);
	for_each(v4.begin(), v4.end(), Myprint());
	cout << endl;
	for_each(v3.begin(), v3.end(), Myprint());
	cout << endl;

}

int main() 
{
	test02();
	system("pause");
	return 0;
}

5.5常用的算术生成算法

注意：算术生成算法是属于小型算法，使用时包含的头文件为numeric

算法简介：accumulate // 计算容器累计元素的和

​ fill //向容器中添加元素

accumulate(iterator beg,iterator end，0）;

fill(iterator beg,iterator end,value)   //向容器中填充元素
//beg开始迭代器
//end 结束迭代器
//value 填充的值

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;

void myprint(int val) 
{
	cout << val << " ";
}

void test03() 
{
	vector<int>v;
	for (int i = 0; i <= 10; i++) 
	{
		v.push_back(i);
	}
	int total = accumulate(v.begin(), v.end(), 0);

	cout << "total = " << total << endl;
	cout << "------------fill算法-------" << endl;
	v.resize(20);
	fill(v.begin(), v.end(), 123);//前边是填充区间，利用fill可以将区间填充为指定的值。
	for_each(v.begin(), v.end(), myprint);
	cout << endl;

}

int main()
{
	test03();
	system("pause");
	return 0;
}

5.6常用的集合算法

算法简介：

set_intersection 		//求两个容器的交集
    set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);
set_union				//求两个容器的并集
 set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);
set_difference			//求两个容器的差集
    set_difference(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);

求并集的两个集合必须得有有序序列

目标容器开辟空间需要两个容器相加

set_union返回值即是并集中最后一个元素的位置。

求差集的两个集合必须是有序序列

目标容器开辟的空间需要从两个容器中取出一个较大的值。

set_difference返回值既是差集中最后一个元素的位置。

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
void myprintt(int val) { cout << val << " "; }
//常用的集合算法
void test04() 
{
	vector<int>v;
	vector<int>v1;
	for (int i = 0; i < 10; i++) 
	{
		v.push_back(i);  //0-9
		v1.push_back(i+5);//5-14
	}

	vector<int>vTarget;
	//目标容器需要提前开辟空间
	//最特殊情况  大容器包含小容器，开辟空间  取小容器的size即可
	vTarget.resize(min(v1.size(), v.size()));
	//获取交集
	cout << "--------------交集------------------" << endl;
	vector<int>::iterator itEnd = set_intersection(v.begin(), v.end(), v1.begin(), v1.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myprintt);  //这里传入itEnd不传入vTarget.end()的原因是因为，最终输出的结果。
	cout << endl;
	cout << "--------------并集------------------" << endl;
	vector<int>vt;
	vt.resize(v1.size() + v.size());
	vector<int>::iterator it = set_union(v.begin(), v.end(), v1.begin(), v1.end(), vt.begin());
	for_each(vt.begin(), it, myprintt);
	cout << endl;
	cout << "--------------差集------------------" << endl;
	vector<int>vt2;
	vt2.resize(max(v1.size(), v.size()));
	cout << "v和v2的差集为：" << endl;
	vector<int>::iterator itend = set_difference(v.begin(), v.end(), v1.begin(), v1.end(), vt2.begin());
	for_each(vt2.begin(), itend, myprintt);
	cout << endl;
}

int main()
{
	test04();
	system("pause");
	return 0;
}

通讯录管理系统

系统中需要实现的功能如下

1. 添加联系人:向通讯录中添加新人，信息包括（姓名、性别、年龄、联系电话、家庭住址）最多记录1000
2. 显示联系人：显示通讯录中所有联系人信息
3. 删除联系人：按照姓名删除指定联系人
4. 查找联系人：按照姓名查看指定联系人信息
5. 修改联系人：按照姓名重新修改指定联系人
6. 清空联系人：清空通讯录中所有信息
7. 退出通讯录：退出当前使用的通讯录

#include <iostream>
#include <string>
#include <cstdlib>
# define MAX 1000 //定义宏变量不需要加上分号。
# define string_max 11
using namespace std;
/*1.展示菜单项
* 
*/
struct Person {
	string name;
	int sex;
	int age;
	string phone;
	string address;
};
struct Addbooks {
	Person personarray[MAX];
	int size = 0;
};
void showMenu() {
	cout << "***** 1.添加联系人 **********" << endl;
	cout << "***** 2.显示联系人 **********" << endl;
	cout << "***** 3.删除联系人 **********" << endl;
	cout << "***** 4.查找联系人 **********" << endl;
	cout << "***** 5.修改联系人 **********" << endl;
	cout << "***** 6.清空联系人 **********" << endl;
	cout << "***** 0.退出通讯录 **********" << endl;
	cout << "*****************************" << endl;
}
void addPerson(struct Addbooks * ads)
{
	//添加 姓名，性别，年龄，电话，地址
	if (ads->size == MAX) 
	{
		cout << "通讯录已满，请删除联系人。";
		return;
	}
	else 
	{
		cout << "请输入联系人的名字：" << endl;
		string name;
		cin >> name;
		ads->personarray[ads->size].name = name;
	}
	// 性别
	cout << "请输入联系人的性别：" << endl;
	int sex=0;
	while (true) {
		cin >> sex;
		if (sex == 1 || sex == 2)
		{
			ads->personarray[ads->size].sex = sex;
			break;
		}
		else {
			cout << "输入类型错误，请重新输入。" << endl;
		}
	}
	//年龄
	cout << "请输入年龄:" << endl;
	int age = 0;
	cin >> age;
	ads->personarray[ads->size].age = age;
	//电话
	cout << "请输入电话：" << endl;
	string phone;
	while (true) {
		cin >> phone;
		if (phone.size() == string_max)
		{
			ads->personarray[ads->size].phone = phone;
			break;
		}
		else
		{
			cout << "输入电话号码长度错误，请重新输入" << endl;
		}
	}
	//地址
	cout << "请输入地址:" << endl;
	string add;
	cin >> add;
	ads->personarray[ads->size].address = add;

	ads->size++;
	cout << "添加成功！" << endl;
	system("pause");
	system("cls");
}
void showPerson(struct Addbooks* ads) {
	if (ads->size == 0)
	{
		cout << "该通讯录为空,请添加联系人。" << endl;
	}
	else 
	{
		for (int i = 0; i < ads->size; i++)
		{
			cout << "姓名：" << ads->personarray[i].name <<
				"\t性别：" << (ads->personarray[i].sex == 1 ? "男" : "女") <<
				"\t年龄：" << ads->personarray[i].age <<
				"\t电话：" << ads->personarray[i].phone <<
				"\t地址：" << ads->personarray[i].address << endl;
		}
	}
	system("pause");
	system("cls");
}
//删除联系人之前还要找到你要删除的联系人是否存在在通讯录中
/*int isExist(struct Addbooks* ads, string compare_name) {
	for (int i = 0; ads->size; i++)
	{
		if (ads->personarray[i].name == compare_name) {
			return i;
		}
	}
	return -1;
}*/

int isExist(struct Addbooks* ads, string compare_name) {
	//参数1：通讯录地址，参数2：对比人名
	for (int i = 0; i < ads->size; i++) {
		//用户找到对应的姓名了
		if (ads->personarray[i].name == compare_name) {
			return i;
		}
	}
	return -1;
}

void delPerson(struct Addbooks* ads) {
	if (ads->size == 0) {
		cout << "该通讯录是空的，无联系人，请添加联系人"<< endl;
	}
	else 
	{
		//通讯录不空进行下边的删除操作
		string compare_name;
		cout << "请输入你要删除的联系人：" << endl;
		cin >> compare_name;
		int ret = isExist(ads, compare_name);
		if (ret != -1)//找到该人，要进行删除操作，然后数据前移
		{
			for (int i = ret; i < ads->size; i++)
			{
				ads->personarray[i] = ads->personarray[i + 1];
			}
			ads->size--;
			cout << "删除成功！" << endl;
		}
		else 
		{
			cout << "查无此人!" << endl;
		}
	}
	system("pause");
	system("cls");
}
void findPerson(struct Addbooks* ads) {
	cout << "请输入查找的联系人名字：" << endl;
	string f_name;
	cin >> f_name;
	int ret = isExist(ads, f_name);
	if (ret != -1) 
	{
		cout << "姓名：" << ads->personarray[ret].name <<
			"\t性别：" << (ads->personarray[ret].sex == 1 ? "男" : "女") <<
			"\t年龄：" << ads->personarray[ret].age <<
			"\t电话：" << ads->personarray[ret].phone <<
			"\t地址：" << ads->personarray[ret].address << endl;
	}
	else {cout << "查无此人！" << endl;}
	system("pause");
	system("cls");
}
void modifyPerson(struct Addbooks* ads) {
	string name;
	cout << "请输入要修改的联系人名字：" << endl;
	cin >> name;
	//看这个联系人是否存在在通讯录中。
	int ret = isExist(ads, name);
	if (ret != -1)//代表找到此人
	{
		//修改信息
		cout << "请输入联系人的名字：" << endl;
		string name;
		cin >> name;
		ads->personarray[ads->size].name = name;
		// 性别
		cout << "请输入联系人的性别：" << endl;
		int sex = 0;
		while (true) {
			cin >> sex;
			if (sex == 1 || sex == 2)
			{
				ads->personarray[ads->size].sex = sex;
				break;
			}
			else {
				cout << "输入类型错误，请重新输入。" << endl;
			}
		}
		//年龄
		cout << "请输入年龄:" << endl;
		int age = 0;
		cin >> age;
		ads->personarray[ads->size].age = age;
		//电话
		cout << "请输入电话：" << endl;
		string phone;
		while (true) {
			cin >> phone;
			if (phone.size() == string_max)
			{
				ads->personarray[ads->size].phone = phone;
				break;
			}
			else
			{
				cout << "输入电话号码长度错误，请重新输入" << endl;
			}
		}
		//地址
		cout << "请输入地址:" << endl;
		string add;
		cin >> add;
		ads->personarray[ads->size].address = add;

		cout << "修改成功！" << endl;
	}
	else 
	{
		cout << "查无此人！" << endl;
	}
	system("pause");
	system("cls");
}
void clearPerson(struct Addbooks* ads) {
	int flag = 0;
	cout << "请确定是否清空联系人？" << endl;
	cout << "1------确定清空" << endl;
	cout << "0-------不清空" << endl;
	cin >> flag;
	while(true)
	{ 
		if (flag == 1 || flag == 0)
		{//输入类型正确进行判断是否清空
			if (flag == 1) {
				//确定清空
				ads->size = 0;
				cout << "通讯录管理系统已经清空！" << endl;
			}
			else {
				cout << "不清空通讯录管理系统。" << endl;
			}
			break;
		}
		else {
			cout << "输入类型错误，请重新输入。" << endl;
		}
	}
	system("pause");
	system("cls");
}
int main() {
	//1.展示菜单
	Addbooks ads;
	int select = 0;
	while (true) {
		showMenu();
		cin >> select;
		switch (select) {
		case 1://添加联系人
			addPerson(&ads); break;
		case 2://显示联系人
			showPerson(&ads); break;
		case 3://删除联系人
			delPerson(&ads); break;
		case 4://查找联系人
			findPerson(&ads); break;
		case 5://修改联系人
			modifyPerson(&ads);
			break;
		case 6://清空联系人
			clearPerson(&ads); 
			break;
		case 0://退出通讯录
			cout << "欢迎下次使用。" << endl;
			system("pause");
			return 0;
			break;
		default:
			break;
		}
	}
	//2.添加联系人

	system("pause");
	return 0;
}

职工管理系统

1.管理系统的需求

职工管理系统可以用来管理公司内所有员工的信息

本教程主要利用C++来实现一个基于多态的职工管理系统

公司中职工分为三类：普通员工、经理、老板，显示信息时，需要显示职工编号、职工姓名、职工岗位、以及职责。

普通员工职责：完成经理交给的任务

经理职责：完成老板交给的任务，并下发任务给员工

老板职责：管理公司所有事务

管理系统中需要实现的功能如下：

1. 退出管理程序：退出当前管理系统。
2. 增加职工信息：实现批量添加职工功能，将信息录入到文件中，职工信息为：职工编号、姓名、部门编号。
3. 显示职工信息：显示公司内部所有职工的信息。
4. 删除离职职工：按照编号删除指定的职工。
5. 修改职工信息：按照编号修改职工个人信息。
6. 查找职工信息：按照职工的编号或者职工的姓名进行查找相关的人员信息
7. 按照编号排序：按照职工编号，进行排序，排序规则由用户指定
8. 清空所有文档：清空文件中记录的所有职工信息（清空前需要进一步确认，防止误删除）

6.1创建职工抽象类

职工的分类为：普通员工、经理、老板

将三种职工抽象到一个类（worker）中，利用多态管理不同职工种类

职工的属性为：职工编号、职工姓名、职工所在的部门编号

职工的行为为：岗位职责信息描述、获取岗位名称

7 添加职工

功能描述：批量添加职工，并且保存到文件中

7.1功能分析

分析：

用户在批量创建时，可能会创建不同种类的职工

如果想将所有不同种类的直职工都放到一个数组中，可以将所有员工的指针维护到一个数组里

如果想在程序中维护这个不定长度的数组，可以将数组创建到堆区，并利用Worker ** 的指针进行维护

(), v4.end(), Greater30(), 3000);
for_each(v4.begin(), v4.end(), Myprint());//传入仿函数的话就传入类的匿名对象,这里传入的是仿函数。
cout << endl;
cout << “----------swap算法----------” << endl;
cout << “替换前：” << endl;
for_each(v4.begin(), v4.end(), Myprint());//传入仿函数的话就传入类的匿名对象,这里传入的是仿函数。
cout << endl;
for_each(v3.begin(), v3.end(), Myprint());
cout << endl;
cout << endl;
cout << “替换后：” << endl;
swap(v4, v3);
for_each(v4.begin(), v4.end(), Myprint());
cout << endl;
for_each(v3.begin(), v3.end(), Myprint());
cout << endl;

}

int main()
{
test02();
system(“pause”);
return 0;
}

## 5.5常用的算术生成算法

注意：算术生成算法是属于小型算法，使用时包含的头文件为numeric

算法简介：accumulate   // 计算容器累计元素的和

​					fill  					//向容器中添加元素

```c++
accumulate(iterator beg,iterator end，0）;

fill(iterator beg,iterator end,value)   //向容器中填充元素
//beg开始迭代器
//end 结束迭代器
//value 填充的值

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;

void myprint(int val) 
{
	cout << val << " ";
}

void test03() 
{
	vector<int>v;
	for (int i = 0; i <= 10; i++) 
	{
		v.push_back(i);
	}
	int total = accumulate(v.begin(), v.end(), 0);

	cout << "total = " << total << endl;
	cout << "------------fill算法-------" << endl;
	v.resize(20);
	fill(v.begin(), v.end(), 123);//前边是填充区间，利用fill可以将区间填充为指定的值。
	for_each(v.begin(), v.end(), myprint);
	cout << endl;

}

int main()
{
	test03();
	system("pause");
	return 0;
}

5.6常用的集合算法

算法简介：

set_intersection 		//求两个容器的交集
    set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);
set_union				//求两个容器的并集
 set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);
set_difference			//求两个容器的差集
    set_difference(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);

求并集的两个集合必须得有有序序列

目标容器开辟空间需要两个容器相加

set_union返回值即是并集中最后一个元素的位置。

求差集的两个集合必须是有序序列

目标容器开辟的空间需要从两个容器中取出一个较大的值。

set_difference返回值既是差集中最后一个元素的位置。

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
void myprintt(int val) { cout << val << " "; }
//常用的集合算法
void test04() 
{
	vector<int>v;
	vector<int>v1;
	for (int i = 0; i < 10; i++) 
	{
		v.push_back(i);  //0-9
		v1.push_back(i+5);//5-14
	}

	vector<int>vTarget;
	//目标容器需要提前开辟空间
	//最特殊情况  大容器包含小容器，开辟空间  取小容器的size即可
	vTarget.resize(min(v1.size(), v.size()));
	//获取交集
	cout << "--------------交集------------------" << endl;
	vector<int>::iterator itEnd = set_intersection(v.begin(), v.end(), v1.begin(), v1.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myprintt);  //这里传入itEnd不传入vTarget.end()的原因是因为，最终输出的结果。
	cout << endl;
	cout << "--------------并集------------------" << endl;
	vector<int>vt;
	vt.resize(v1.size() + v.size());
	vector<int>::iterator it = set_union(v.begin(), v.end(), v1.begin(), v1.end(), vt.begin());
	for_each(vt.begin(), it, myprintt);
	cout << endl;
	cout << "--------------差集------------------" << endl;
	vector<int>vt2;
	vt2.resize(max(v1.size(), v.size()));
	cout << "v和v2的差集为：" << endl;
	vector<int>::iterator itend = set_difference(v.begin(), v.end(), v1.begin(), v1.end(), vt2.begin());
	for_each(vt2.begin(), itend, myprintt);
	cout << endl;
}

int main()
{
	test04();
	system("pause");
	return 0;
}

通讯录管理系统

系统中需要实现的功能如下

1. 添加联系人:向通讯录中添加新人，信息包括（姓名、性别、年龄、联系电话、家庭住址）最多记录1000
2. 显示联系人：显示通讯录中所有联系人信息
3. 删除联系人：按照姓名删除指定联系人
4. 查找联系人：按照姓名查看指定联系人信息
5. 修改联系人：按照姓名重新修改指定联系人
6. 清空联系人：清空通讯录中所有信息
7. 退出通讯录：退出当前使用的通讯录

#include <iostream>
#include <string>
#include <cstdlib>
# define MAX 1000 //定义宏变量不需要加上分号。
# define string_max 11
using namespace std;
/*1.展示菜单项
* 
*/
struct Person {
	string name;
	int sex;
	int age;
	string phone;
	string address;
};
struct Addbooks {
	Person personarray[MAX];
	int size = 0;
};
void showMenu() {
	cout << "***** 1.添加联系人 **********" << endl;
	cout << "***** 2.显示联系人 **********" << endl;
	cout << "***** 3.删除联系人 **********" << endl;
	cout << "***** 4.查找联系人 **********" << endl;
	cout << "***** 5.修改联系人 **********" << endl;
	cout << "***** 6.清空联系人 **********" << endl;
	cout << "***** 0.退出通讯录 **********" << endl;
	cout << "*****************************" << endl;
}
void addPerson(struct Addbooks * ads)
{
	//添加 姓名，性别，年龄，电话，地址
	if (ads->size == MAX) 
	{
		cout << "通讯录已满，请删除联系人。";
		return;
	}
	else 
	{
		cout << "请输入联系人的名字：" << endl;
		string name;
		cin >> name;
		ads->personarray[ads->size].name = name;
	}
	// 性别
	cout << "请输入联系人的性别：" << endl;
	int sex=0;
	while (true) {
		cin >> sex;
		if (sex == 1 || sex == 2)
		{
			ads->personarray[ads->size].sex = sex;
			break;
		}
		else {
			cout << "输入类型错误，请重新输入。" << endl;
		}
	}
	//年龄
	cout << "请输入年龄:" << endl;
	int age = 0;
	cin >> age;
	ads->personarray[ads->size].age = age;
	//电话
	cout << "请输入电话：" << endl;
	string phone;
	while (true) {
		cin >> phone;
		if (phone.size() == string_max)
		{
			ads->personarray[ads->size].phone = phone;
			break;
		}
		else
		{
			cout << "输入电话号码长度错误，请重新输入" << endl;
		}
	}
	//地址
	cout << "请输入地址:" << endl;
	string add;
	cin >> add;
	ads->personarray[ads->size].address = add;

	ads->size++;
	cout << "添加成功！" << endl;
	system("pause");
	system("cls");
}
void showPerson(struct Addbooks* ads) {
	if (ads->size == 0)
	{
		cout << "该通讯录为空,请添加联系人。" << endl;
	}
	else 
	{
		for (int i = 0; i < ads->size; i++)
		{
			cout << "姓名：" << ads->personarray[i].name <<
				"\t性别：" << (ads->personarray[i].sex == 1 ? "男" : "女") <<
				"\t年龄：" << ads->personarray[i].age <<
				"\t电话：" << ads->personarray[i].phone <<
				"\t地址：" << ads->personarray[i].address << endl;
		}
	}
	system("pause");
	system("cls");
}
//删除联系人之前还要找到你要删除的联系人是否存在在通讯录中
/*int isExist(struct Addbooks* ads, string compare_name) {
	for (int i = 0; ads->size; i++)
	{
		if (ads->personarray[i].name == compare_name) {
			return i;
		}
	}
	return -1;
}*/

int isExist(struct Addbooks* ads, string compare_name) {
	//参数1：通讯录地址，参数2：对比人名
	for (int i = 0; i < ads->size; i++) {
		//用户找到对应的姓名了
		if (ads->personarray[i].name == compare_name) {
			return i;
		}
	}
	return -1;
}

void delPerson(struct Addbooks* ads) {
	if (ads->size == 0) {
		cout << "该通讯录是空的，无联系人，请添加联系人"<< endl;
	}
	else 
	{
		//通讯录不空进行下边的删除操作
		string compare_name;
		cout << "请输入你要删除的联系人：" << endl;
		cin >> compare_name;
		int ret = isExist(ads, compare_name);
		if (ret != -1)//找到该人，要进行删除操作，然后数据前移
		{
			for (int i = ret; i < ads->size; i++)
			{
				ads->personarray[i] = ads->personarray[i + 1];
			}
			ads->size--;
			cout << "删除成功！" << endl;
		}
		else 
		{
			cout << "查无此人!" << endl;
		}
	}
	system("pause");
	system("cls");
}
void findPerson(struct Addbooks* ads) {
	cout << "请输入查找的联系人名字：" << endl;
	string f_name;
	cin >> f_name;
	int ret = isExist(ads, f_name);
	if (ret != -1) 
	{
		cout << "姓名：" << ads->personarray[ret].name <<
			"\t性别：" << (ads->personarray[ret].sex == 1 ? "男" : "女") <<
			"\t年龄：" << ads->personarray[ret].age <<
			"\t电话：" << ads->personarray[ret].phone <<
			"\t地址：" << ads->personarray[ret].address << endl;
	}
	else {cout << "查无此人！" << endl;}
	system("pause");
	system("cls");
}
void modifyPerson(struct Addbooks* ads) {
	string name;
	cout << "请输入要修改的联系人名字：" << endl;
	cin >> name;
	//看这个联系人是否存在在通讯录中。
	int ret = isExist(ads, name);
	if (ret != -1)//代表找到此人
	{
		//修改信息
		cout << "请输入联系人的名字：" << endl;
		string name;
		cin >> name;
		ads->personarray[ads->size].name = name;
		// 性别
		cout << "请输入联系人的性别：" << endl;
		int sex = 0;
		while (true) {
			cin >> sex;
			if (sex == 1 || sex == 2)
			{
				ads->personarray[ads->size].sex = sex;
				break;
			}
			else {
				cout << "输入类型错误，请重新输入。" << endl;
			}
		}
		//年龄
		cout << "请输入年龄:" << endl;
		int age = 0;
		cin >> age;
		ads->personarray[ads->size].age = age;
		//电话
		cout << "请输入电话：" << endl;
		string phone;
		while (true) {
			cin >> phone;
			if (phone.size() == string_max)
			{
				ads->personarray[ads->size].phone = phone;
				break;
			}
			else
			{
				cout << "输入电话号码长度错误，请重新输入" << endl;
			}
		}
		//地址
		cout << "请输入地址:" << endl;
		string add;
		cin >> add;
		ads->personarray[ads->size].address = add;

		cout << "修改成功！" << endl;
	}
	else 
	{
		cout << "查无此人！" << endl;
	}
	system("pause");
	system("cls");
}
void clearPerson(struct Addbooks* ads) {
	int flag = 0;
	cout << "请确定是否清空联系人？" << endl;
	cout << "1------确定清空" << endl;
	cout << "0-------不清空" << endl;
	cin >> flag;
	while(true)
	{ 
		if (flag == 1 || flag == 0)
		{//输入类型正确进行判断是否清空
			if (flag == 1) {
				//确定清空
				ads->size = 0;
				cout << "通讯录管理系统已经清空！" << endl;
			}
			else {
				cout << "不清空通讯录管理系统。" << endl;
			}
			break;
		}
		else {
			cout << "输入类型错误，请重新输入。" << endl;
		}
	}
	system("pause");
	system("cls");
}
int main() {
	//1.展示菜单
	Addbooks ads;
	int select = 0;
	while (true) {
		showMenu();
		cin >> select;
		switch (select) {
		case 1://添加联系人
			addPerson(&ads); break;
		case 2://显示联系人
			showPerson(&ads); break;
		case 3://删除联系人
			delPerson(&ads); break;
		case 4://查找联系人
			findPerson(&ads); break;
		case 5://修改联系人
			modifyPerson(&ads);
			break;
		case 6://清空联系人
			clearPerson(&ads); 
			break;
		case 0://退出通讯录
			cout << "欢迎下次使用。" << endl;
			system("pause");
			return 0;
			break;
		default:
			break;
		}
	}
	//2.添加联系人

	system("pause");
	return 0;
}

职工管理系统

1.管理系统的需求

职工管理系统可以用来管理公司内所有员工的信息

本教程主要利用C++来实现一个基于多态的职工管理系统

公司中职工分为三类：普通员工、经理、老板，显示信息时，需要显示职工编号、职工姓名、职工岗位、以及职责。

普通员工职责：完成经理交给的任务

经理职责：完成老板交给的任务，并下发任务给员工

老板职责：管理公司所有事务

管理系统中需要实现的功能如下：

1. 退出管理程序：退出当前管理系统。
2. 增加职工信息：实现批量添加职工功能，将信息录入到文件中，职工信息为：职工编号、姓名、部门编号。
3. 显示职工信息：显示公司内部所有职工的信息。
4. 删除离职职工：按照编号删除指定的职工。
5. 修改职工信息：按照编号修改职工个人信息。
6. 查找职工信息：按照职工的编号或者职工的姓名进行查找相关的人员信息
7. 按照编号排序：按照职工编号，进行排序，排序规则由用户指定
8. 清空所有文档：清空文件中记录的所有职工信息（清空前需要进一步确认，防止误删除）

6.1创建职工抽象类

职工的分类为：普通员工、经理、老板

将三种职工抽象到一个类（worker）中，利用多态管理不同职工种类

职工的属性为：职工编号、职工姓名、职工所在的部门编号

职工的行为为：岗位职责信息描述、获取岗位名称

7 添加职工

功能描述：批量添加职工，并且保存到文件中

7.1功能分析

分析：

用户在批量创建时，可能会创建不同种类的职工

如果想将所有不同种类的直职工都放到一个数组中，可以将所有员工的指针维护到一个数组里

如果想在程序中维护这个不定长度的数组，可以将数组创建到堆区，并利用Worker ** 的指针进行维护