【笔记·自用】C++入门

·看（MuQuanyu/黑马程序员）视频的笔记

一、初识C++

1.1 编程，算法是什么？

1. 编程 ：你和计算机打交道的方式。
2. 算法 ：解决方案的准确而完整的一个描述。（帮助你解决问题）

1.2 第一个C++程序

1. 输出 “ Hello World ！”

#include<iostream>
using namespace std;

int main()
{
	cout << "Hello World ! " << endl;//在屏幕中输出一个“Hello World ! ”
	system("pause");
	return 0;
}

1.3 注释

1. 行注释 “ // ” ，段注释 “ /* */ ”

1.4 变量

1. 作用 ： 给一段指定的内存空间起名，方便操作这段内存。
2. 语法 ： 数据类型 变量名 = 变量的初始值 ; int a = 10 ;

1.5 常量

1. 作用 ： 用于记录程序中不可变的数据。
2. 定义方式 ：
   （1）#define 宏常量 ： #define 常量名 常量值
   通常在文本上方定义，表示一个常量。
   （2）const 修饰的变量 ： const 数据类型 常量名 = 常量值
   通常在变量定义前加关键字const，修饰该变量为常量，不可修改。

1.6 关键字

1. 作用 ： 预先保留的单词 在定义变量/常量的时候不能用关键字

1.7 标识符命名规则

1. 标识符不能是关键字。
2. 标识符只能由字母、数字、下划线组成。
3. 第一个字符必须字母或下划线。
4. 标识符中区分字母大小写。

二、数据类型

1. 作用 ： 给变量分配合适的内存空间。

2.1 sizeof关键字

1. 作用 ： 统计数据类型所占用的内存大小。/字节
2. 语法 ： sizeof（数据类型/变量名）cout << "int 类型占用的内存大小：" << sizeof(int) << endl;

2.2 整型

1. 作用 ：整型变量表示整数类型的数据。

数据类型	占用空间 / 字节
short (短整型)	2
int (整型)	4
long (长整型)	Win：4 、 Linux：4 / 8
long long (长长整型)	8

2.3 实型（浮点型）

1. 用于表示小数。
2. 分类 ：

• 单精度 ：floatfloat f1 = 3.14f；（一般在数字类型后面多加一个“f”因为系统默认小数为双精度
• 双精度 ：double

3. 默认情况下输出一个小数，会显示6位有效数字。
   科学计数法：3e2---3*10^2 / 3e-2---3*0.1^2

数据类型	占用空间 / 字节
float (单精度)	4
double (双精度)	8

2.4 字符型

1. 作用 ：字符型变量用于显示单个子符。
2. 语法 ：char ch = ‘a’ ；
   1.用单引号括起 2. 单引号内只能有一个字符

数据类型	占用空间 / 字节
char	1

ASCII码对照表：

a - 97
A - 65

2.5 转义字符

转义字符	字 符 值	输 出 结 果
\’	一个单撇号（'）	输出单撇号字符’
\‘’	一个双撇号（"）	输出双撇号字符"
\?	一个人问号（?）	输出问号字符?
\\	一个反斜杠（\）	输出反斜杠字符\
\a	警告(alert)	产生声音或视觉信号
\b	退格(backspace)	将光标当前位置后退一个字符
\f\	换页(from feed)	将光标当前位置移到下一页的开头
\n	换行	将光标当前位置移到下一行的开头
\r	回车（carriagereturn	将光标当前位置移到本行的开头
\t	水平制表符	将光标当前位置移到下一个Tab位置
\v	垂直制表符	将光标当前位置移到下一个垂直表对齐点
\o、\oo、\ooo	其中o表示一个八进制数字	与该八进制码对应的ASCII字符 与该八进制码对应的字符
\xh[h…]	其中h代表一个十六进制数字	与该十六进制码对应的ASCII字符 与该十六进制码对应的字符

\t 一个tap站8个格

2.6 字符串型

1. 作用 ： 用于表示一串字符。
2. 风格 ：
   （1）C风格：char 变量名[] = "字符串值"
   （2）C++风格：string 变量名 = "字符串值 //加一个头文件 #include<string>"

2.7 布尔类型

1. 作用 ：代表真或假的值。
   bool bo = true ;
2. bool 类型只有两个值 ：

• true —真（1）//非零的值都为真
• false —假（0）

数据类型	占用空间 / 字节
bool	1

2.8 数据的输入

1. 作用 ：从键盘获取数据。
2. 关键字 ：cin
3. 语法 ：cin >> 变量

三、运算符

1. 作用 ： 用于执行代码的运算。
2. 运算符的类型 ：

类型	作用
算数运算符	用于处理四则运算
赋值运算符	用于将表达式的值赋给变量
比较运算符	用于表达式的比较，并返回一个真值或假值
逻辑运算符	用于根据表达式的值返回真值或假值

3.1 算数运算符

1. 作用 ：用于处理四则运算。

• 两个整数相除，结果依然是整数。
• 两数相除，除数不能为“ 0 ” 。
• 取模运算的本质是取余数。
• 两个小数是不可以做取模运算的。（至少有一个整数）

3.2 赋值运算符

1. 作用 ：用于将表达式的值赋给变量。

3.3 比较运算符

1. 作用 ：用于表达式的比较，并返回一个真值或假值 。

false = 0
true = 1

3.4 逻辑运算符

1. 作用 ：用于根据表达式的值返回真值或假值。

运算符	术语	示例	结果
!	非	!a	如果a为假，则!a为真，如果a为真，则!a为假。
&&	与	a&&b	如果a和b为真，则结果为真，否则为假。
||	或	a||b	如果a和b有一个为真，则结果为真，二者都为假时，结果为假。

非零的数都为真 // a = 10；!a = 0 ;

四、程序流程结构

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

• 顺序结构 ： 程序按顺序执行，不发生跳转。
• 选择结构 ： 依据条件是否满足，有选择的执行相应功能，
• 循环结构 ： 依据条件是否满足，循环多次执行某段代码。

4.1 选择结构

4.1.1 if语句

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

• 单行格式if语句 ： if(条件){条件满足执行的语句}
• 多行格式if语句 ： if(条件){条件满足执行的语句}else{条件不满足执行的语句}
• 多条件的if语句 ： if(条件1){条件1满足执行的语句}else if(条件2){条件2满足执行的语句}…else{条件不满足执行的语句}

• 嵌套if语句 ： 在if语句中嵌套使用if语句。

4.1.2 三目运算符

1. 作用 ： 实现简单判断。
2. 语法 ： 表达式1 ? 表达式2 ：表达式3

• 如果表达式1的值为真，执行表达式2，并返回表达式2的结果。
• 如果表达式1的值为假，执行表达式3，并返回表达式3的结果。
• C++中三目运算符返回的变量可以继续赋值。
  a=10；b=20;c=(a>b?a:b);(a>b?a:b)=100;--->a=10;b=100;c=10;

4.1.3 switch语句

1. 作用 ： 执行多条分支语句。
2. 语法 ：

switch(表达式)
{
	case 结果1 : 执行语句 ; break;
	case 结果2 : 执行语句 ; break;
	···
	default : 执行语句 ; break;
}

• switch 结构清晰，执行效率高，但不判断区间。

4.2 循环结构

4.2.1 while循环语句

1. 作用 ： 满足循环条件，执行循环语句。
2. 语法 ： while( 循环条件 ) { 循环语句 }
   只要循环条件的结果为真，就执行循环语句。

4.2.2 do···while循环语句

1. 作用 ： 满足循环条件，执行循环语句。
2. 语法 ： do{ 循环语句 } while( 循环条件 )
   和while区别是，先执行一次循环语句，再判断循环条件。

4.2.3 for循环语句

1. 作用 ： 满足循环条件，执行循环语句。
2. 语法 ： for(起始表达式 ; 条件表达式 ; 末尾循环体) { 循环语句 }

4.2.4 嵌套循环

1. 作用 ： 在循环体中再嵌套一层循环，解决一些实际问题。
2. 例 ：打印乘法口诀表 。

#include<iostream>
using namespace std;
int main()
{
	int i,j;
	for(i=1;i<10;i++)
	{
		for(j=1;j<=i;j++)
		{
			cout << i << " * " << j << " = " << i*j << " " ;
		}
		cout << "\n";
	}
	return 0;
}

4.3 跳转语句

4.3.1 break语句

1. 作用 ： 用于跳出选择结构或者循环结构。
2. 使用的时机 ：

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

4.3.2 continue语句

1. 作用 ： 在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环。
   continue继续执行下一次循环，break直接跳出循环

4.3.3 goto语句

1. 作用 ： 可以无条件跳转语句。
2. 语法：goto 标记；
3. 如果标记的名称存在，执行到goto语句时，会跳转到表记位置。

五、数组

1. 概述 ： 所谓数组，就是一个集合，里面存放了相同类型的数据元素。
2. 特点 ：

• 特点1 ： 数组中的每个数据元素都是相同的数据类型。
• 特点2 ： 数组是由连续的内存位置组成的。

5.1 一维数组

5.1.1 一维数组定义方式

1. 数据类型 数组名[ 数组长度 ] ;
2. 数据类型 数组名[ 数组长度 ] = { 值1, 值2, ··· } // 如果在初始化数组时，没有全部填完，会用0来填充剩余数据;
3. 数据类型 数组名[ ] = { 值1, 值2, ··· };

5.1.2 一维数组组名

1. 用途 ：

• 可以统计整个数组在内存中的长度。sizeof ( 数组名 ) / sizeof ( 数组名[ 0 ] );
• 可以获取数组在内存中的首地址。cout << 数组名 << endl ; //十六进制 cout << （ int ）数组名 << endl ; //强转为十进制
• 可以获取数组中第一个元素的地址。cout << &数组名[ 0 ] << endl ;等于数组在内存中的首地址

2. 数组名是常量，不可以进行赋值操作。

5.1.3 冒泡排序

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

• 比较相邻元素，如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
• 重复以上步骤，每次比较次数-1，直到不需要比较。

2. 代码 ：

#include<iostream>

using namespace std;

int main()
{
	int arr[9] = {4,2,8,0,5,7,1,3,9};
	cout << "排序前为：";
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << "  " ;
	}
	cout << endl;	
	for(int i = 0; i < 9 - 1; i++)
	{
		for(int j = 0; j < 9 - i - 1; j++)
		{
			if(arr[j] > arr[j + 1])
			{
			int temp = arr[j];
			arr[j] = arr[j + 1];
			arr[j + 1] = temp;				
			}
		}
	}
	cout << "排序后为：";
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << "  " ;
	}
	return 0;
}

运行结果：

5.2 二维数组

5.2.1 二维数组定义方式

1. 数据类型 数组名[ 行数 ][ 列数 ] ;
2. 数据类型 数组名[ 行数 ][ 列数 ] = { { 数据1 ， 数据2 } ，{数据3 ， 数据4 } }; //代码可读性高
3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1 ， 数据2 ， 数据3 ， 数据4 };
4. 数据类型 数组名[ ][ 列数 ] = { 数据1 ， 数据2 ， 数据3 ， 数据4 };

5.2.2 二维数组组名

1. 用途 ：

• 查看二维数组所占用的空间。cout << sizeof ( 数组名 ) ;
• 查看二维数组第一行所占用的空间。cout << sizeof ( 数组名[ 0 ] ) ;
• 查看二维数组第一个元素所占用的空间。cout << sizeof ( 数组名[ 0 ] [ 0 ] ) ;
• 二维数组的行数：cout << sizeof ( 数组名 ) / sizeof ( 数组名[ 0 ] ) ;
• 二维数组的列数：cout << sizeof ( 数组名 ) [ 0 ] / sizeof ( 数组名[ 0 ] [ 0 ] ) ;
• 获取二维数组的首地址。cout << （int）数组名 << endl ;

六、函数

1. 作用 ： 将一段经常适应的代码封装起来，减少重复代码。

6.1 函数的定义

• 步骤：

1. 返回值类型
2. 函数名
3. 参数表列
4. 函数体语句
5. return 表达式

• 语法 ：

返回值类型 函数名 ( 参数表列 )
{
	函数体语句
	return 表达式
}

6.2 函数的调用

1. 功能 ： 使用定义好的函数。
2. 语法 ： 函数名 （参数）
3. 举例：

#include<iostream>
using namespace std;

//定义加法函数
//函数定义的时候，num1和num2没有真实数据
//只是一个形式上的参数，简称 形参
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}

int main()
{
	//a和b称为实际参数，简称 实参
	int a = 10;
	int b = 20;
	//调用add函数
	//当调用函数时，实参的值会传递给形参
	int sum = add( a , b ); 
	cout << "a + b = " << sum << endl;
	return 0;
}

6.3 值传递

1. 所谓值传递，就是函数调用时实参将值传给形参。
2. 值传递时，如果形参发生改变，并不会影响实参。

#include<iostream>
using namespace std;

//如果函数不需要返回值，声明的时候可以写 void
void swap(int num1, int num2)
{
	cout << "交换前：num1 = " << num1 << " num2 = " << num2 <<endl;
	int temp = num1;
	num1 = num2;
	num2 = temp;
	cout << "交换前：num1 = " << num1 << " num2 = " << num2 <<endl;
	//return ; 返回值不需要的时候可以不写return
}
int main()
{
	int a = 10;
	int b = 20;
	cout << "交换前：a = " << a << " b = " << b <<endl;
	swap( a , b );
	cout << "交换后：a = " << a << " b = " << b <<endl;
	return 0;
}

6.4 函数的常见样式

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

#include<iostream>
using namespace std;

void test01() //无参无返
 {
		cout <<  "this is test01 " << endl;
}

void test02( int a )//有参无返
{
		cout <<  "this is test02 a = " << a << endl;
}

int test03()//无参有返
{
		cout <<  "this is test03 " << endl;
		return 1000;
}

int test04( int a )//有参有返
{
		cout <<  "this is test04 a = " << a << endl;
		return a;
}

int main()
{
	test01();//无参无返
	test02(100);//有参无返
	int num1 = test03();//无参有返
	cout <<  "num1 =  " << num1 << endl;
	int num2 = test04(10000);//有参有返
	cout <<  "num2 =  " << num2 << endl;
	return 0;
}

6.5 函数的声明

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

• 函数的声明可以多次，但函数的定义只能有一次。

#include<iostream>
using namespace std;

//提前告诉编译器函数的存在，可以利用函数的声明
int max(int num1, int num2);

int main()
{
	int a = 10;
	int b = 20;
	cout << max(a , b) << endl;
	return 0;
}

//定义比较函数，两个数比较，返回较大值
int max(int num1, int num2)
{
	return ( num1 > num2 ? num1 : num2 );
}

6.6 函数的分支文件编写

1. 作用 ： 让代码结构更清晰。
2. 步骤 ：

• 创建后缀名为 .h 的头文件。
• 创建后缀名为 .cpp 的源文件。
• 在头文件中写函数的声明。
• 在源文件中写函数的定义。

代码 :

头文件 .h

#include<iostream>
using namespace std;

int max(int num1, int num2);

源文件 .cpp

#include"项目1.h"

int max(int num1, int num2)
{
	return ( num1 > num2 ? num1 : num2 );
}

程序代码：

#include<iostream>
using namespace std;

#include"项目1.h"

void main()
{
	int a = 10;
	int b = 20;
	cout << max(a , b) << endl;
}

结果：

七、指针

1. 作用 ： 可以通过指针间接访问内存。

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

7.1 指针变量的定义和使用

1. 指针的定义（语法） ：数据类型 *指针变量名；
2. 指针的使用 ：

• 可以通过解引用的方式来找到指针指向的内存。
• 指针前加 * 代表解引用，找到指针指向的内存中的的数据。

#include<iostream>
using namespace std;

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

7.2 指针所占内存空间

1. 在32位操作系统下 ： 占用4个字节的空间。//使用 sizeof（）查看
2. 在64位操作系统下 ： 占用8个字节的空间。
   不管什么数据类型，占用字节不变

7.3 空指针和野指针

• 空指针 ：

1. 空指针 ： 指针变量指向内存中编号为0的空间。空指针指向的内存是不能访问的
2. 用途 ： 初始化指针变量。

#include<iostream>
using namespace std;

int main()
{
	int *p = NULL;
	//运行报错
	//内存编号 0 ~ 255 为系统占用内存，不允许用户访问
	cout << *p << endl;	
	return 0;
}

• 野指针 ：

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

#include<iostream>
using namespace std;

int main()
{
	int *p = (int *)0x1100;
	//运行报错
	//在程序中尽量避免出现野指针
	cout << *p << endl;	
	return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

7.4 const修饰指针

1. const修饰指针 - - - 常量指针 const 数据类型 *指针变量名

指针的指向可以修改，但是指针指向值不可以修改。

2. const修饰常量 - - - 指针常量 数据类型 * const 指针变量名

指针的指向不可以修改，但是指针指向值可以修改。

3. const即修饰指针，又修饰常量。 const 数据类型 * const 指针变量名

指针的指向和指针指向值都不可以修改。

7.5 指针和数组

1. 作用 ： 利用指针访问数组中的元素。

#include<iostream>
using namespace std;

int main()
{
	int arr[9] = {1,2,3,4,5,6,7,8,9};
	//cout << "数组第一个元素为：" << arr[0] << endl;
	int *p = arr; //arr为数组的首地址
	
	//cout << "利用指针访问第一个元素为：" << *p << endl;
	//p++; //让指针向后偏移4个字节
	//cout << "利用指针访问第二个元素为：" << *p << endl;
	
	int i = 0;
	for(i , p; i < 9; i++ , p++)
	{
		cout << "利用指针访问第" << i+1 <<"个元素为：" << *p << endl;
	}
	return 0;
}

7.6 指针和函数

1. 作用 ： 利用指针作函数的参数，可以修改实参的值。
2. 值传递 ： 函数的实参和形参。
3. 地址传递 ：可以修饰实参。

#include<iostream>
using namespace std;

void swap1(int p1 , int p2);
void swap2(int *p1 , int *p2);

int main()
{
	int a = 10;
	int b = 20;
	
	swap1(a , b);
	
	cout << "swap1 a = " << a << "  ";
	cout << "swap1 b = " << b << endl;
	
	swap2(&a , &b);

	cout << "swap1 a = " << a << "  ";
	cout << "swap1 b = " << b << endl;
	
	return 0;
}

void swap1(int p1 , int p2)
{
	int temp;
	temp = p1;
	p1 = p2;
	p2 = temp;
}

void swap2(int *p1 , int *p2)
{
	int temp;
	temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

7.7 指针、数组、函数

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

#include<iostream>

using namespace std;

void bubbleSort(int *arr , int len );
void printArray(int *arr , int len );

int main()
{
	int arr[10] = {4,3,6,9,1,2,10,8,7,5};
	int len = sizeof(arr) / sizeof(arr[0]);
	bubbleSort(arr , len);
	printArray(arr , len);
	return 0;
}

void printArray(int *arr , int len )
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << "  " ;
	}
}

//冒泡排序函数，参数1，数组首地址， 参数2 数组长度
void bubbleSort(int *arr , int len )
{
	for(int i = 0; i < len - 1; i++)
	{
		for(int j = 0; j < len - i - 1; j++)
		{
			if(arr[j] > arr[j + 1])
			{
			int temp = arr[j];
			arr[j] = arr[j + 1];
			arr[j + 1] = temp;				
			}
		}
	}	
}

八、结构体

1. 概念 ： 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。

8.1 结构体定义和使用

1. 语法 ：struct 结构体名 { 结构体成员列表 } ；
2. 创建变量 ：

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

#include<iostream>

#include<string>

using namespace std;

struct Student
{
	string name;
	int age;
	int score;
}S3 ;//定义结构体时顺便创建变量

int main()
{
	//struct 结构体名 变量名
	//创建变量时 struct关键字可以不写
	struct Student S1;
	//给S1属性赋值，通过. 访问结构体变量中的属性
	S1. name = "张三";
	S1. age = 18;
	S1. score = 100;
	cout << "S1 : " << "姓名 ：" << S1. name << " 年龄 ： " << S1. age << " 分数" << S1. score << endl;
	
	//struct 结构体名 变量名 = { 成员1值 ， 成员2值 }
	struct Student S2 = {"李四" , 20 , 90};
	cout << "S2 : " << "姓名 ：" << S2. name << " 年龄 ： " << S2. age << " 分数" << S2. score << endl;
	
	S3. name = "王五";
	S3. age = 14;
	S3. score = 60;
	cout << "S3 : " << "姓名 ：" << S3. name << " 年龄 ： " << S3. age << " 分数" << S3. score << endl;
}

总结 ：
1.定义结构体时关键字struct不可以省略。
2.创建结构体变量时关键字struct可以省略。
3.结构体变量利用操作符 “ . ”访问成员。

8.2 结构体数组

1. 作用 ： 将自定义的结构体放入到数组中方便维护。
2. 语法 ： struct 结构体名 数组名 [ 元素个数 ] = { { } ，{ } ， ··· { } }

#include<iostream>

#include<string>

using namespace std;

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

int main()
{
	struct Student Stuarr[3]
	{
		{"s1", 16, 100},
		{},
		{"s3", 14, 80}
	};
	Stuarr[1]. name = "s2";
	Stuarr[1]. age = 23;
	Stuarr[1]. score = 98;
	
	for(int i = 0; i < 3; i++)
	{
	cout << "姓名 ：" << Stuarr[i]. name << " 年龄 ： " << Stuarr[i]. age << " 分数" << Stuarr[i]. score << endl;
	}
}

8.3 结构体指针

1. 作用 ：通过指针访问结构体中的成员。
2. 利用操作符->可以通过结构体指针访问结构体属性。

#include<iostream>

#include<string>

using namespace std;

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

int main()
{
	struct Student S = {"李四" , 20 , 90};
	Student *p = &S;
	cout << "姓名 ：" << p -> name << " 年龄 ： " << p -> age << " 分数 : " << p -> score << endl;
}

8.4 结构体嵌套结构体

1. 作用 ： 结构体中的成员可以是另一个结构体。
2. 例子：老师辅导学生，一个老师的结构体中记录一个学生的结构体。

#include<iostream>

#include<string>

using namespace std;

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

struct Teacher
{
	string name;
	int id;
	int age;
	struct Student S;
};

int main()
{
	struct Teacher T = {"老王",12350,50,{"张三",18,100}};
	//T. S. name = "张三";
	//T. S. age = 18;
	//T. S. score = 100;
	cout << "老师姓名 ：" << T. name 
	<< " 老师id ：" << T. id 
	<< " 老师年龄 ： " << T. age 
	<< " 学生姓名 ： " << T. S. name
	<< " 学生年龄 ： " << T. S. age
	<< " 学生成绩 ： " << T. S. score   
	<< endl;
}

8.5 结构体做函数参数

1. 作用 ： 将结构体作为参数向函数中传递。
2. 传递方式 ：

• 值传递
• 地址传递

#include<iostream>

#include<string>

using namespace std;

void printStudent1(struct Student S);
void printStudent2(struct Student *S);

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

int main()
{
	struct Student S = {"张三",18,100};
	cout << "main中打印 ：" 
	<< "姓名 ： " << S. name
	<< " 年龄 ： " << S. age
	<< " 成绩 ： " << S. score   
	<< endl;
	printStudent1(S);
	cout << "main中打印 ：" 
	<< "姓名 ： " << S. name
	<< " 年龄 ： " << S. age
	<< " 成绩 ： " << S. score   
	<< endl;
	printStudent2(&S);
	cout << "main中打印 ：" 
	<< "姓名 ： " << S. name
	<< " 年龄 ： " << S. age
	<< " 成绩 ： " << S. score   
	<< endl;
	return 0;
}

void printStudent1(struct Student S)
{
	S.age = 100;
	cout << "printStudent1中打印 ：" 
	<< "姓名 ： " << S. name
	<< " 年龄 ： " << S. age
	<< " 成绩 ： " << S. score   
	<< endl;
}
void printStudent2(struct Student *S)
{
	S -> age = 200;
	cout << "printStudent2中打印 ：" 
	<< "姓名 ： " << S -> name
	<< " 年龄 ： " << S -> age
	<< " 成绩 ： " << S -> score   
	<< endl;
}
}

8.6 结构体中const使用场景

1. 作用 ： 用const来防止误操作。

#include<iostream>
#include<string>

using namespace std;

void printStudent(const struct Student *S);

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

int main()
{
	struct Student S = {"张三",18,100};

	printStudent(&S);

	return 0;
}

//将函数中的形参改为指针，可以减少内存空间
//（一个指针占用4个字节），而且不会复制新的副本出来
void printStudent(const struct Student *S)
{
	//S -> age = 12; （报错）
	//加入const之后，一旦有修改的操作就会报错
	//可以防止误操作
	cout << "printStudent中打印 ：" 
	<< "姓名 ： " << S -> name
	<< " 年龄 ： " << S -> age
	<< " 成绩 ： " << S -> score   
	<< endl;
}