C++基础笔记（包含函数、指针、结构体）—基于《黑马程序员》

※基础模块

1、命名规范

通用规则：标识符不可用关键字直接命名；标识符是由字母、数字、下划线构成；标识符第一个字符只可用字母或下划线；标识符区分大小写。（标识符是用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。）

• 命名空间：以小写字母命名。
• 类与结构：大写字母“C”开头 + 一个或多个单词。
• 宏、枚举值：全部大写，且用下划线连接。
• 函数：
  – 函数的名称：由一个或多个单词组成，首字母大写。
  (函数名应当使用"动词"或者"动词＋名词"(动宾词组)的形式。)
  – 保护成员函数：开头以一个下划线开头。
  – 私有成员函数：开头以两个下划线开头。
  – 虚函数：以“Do”开头。
  – 回调和事件处理函数：以“On”开头。
• 变量、常量： 前缀 ＋ 类型 ＋ 一个或多个单词(一般是"名词"或"名词+形容词")。
• 类型：类型名称的每个单词的首字母都大写，但是不包括下划线

2、注释

• 单行注释：通常放在一行代码上方或语句末尾，对该行代码进行说明。 代码：// 内容
• 多行注释：通常放在一行代码上方，对该段代码进行说明。 代码：/* 内容 */

3、输入输出

正常情况下，C++每个输入输出语句前需要加std::(例如输入的语句是std::cin>>内容;)，但由于个人习惯(懒)，喜欢使用命名空间 using namespace std;，这样后面的输入输出，就无需再进行添加std::，具体语法如下：

• 输入：cin >> 内容;
• 输出：cout << 内容;
• 输入输出例子（不考虑异常，异常处理在后面讲）：
  （这里末尾的endl是让输出(cout)的时候进行换行，不加也不影响结果。）

#include 
using namespace std;

int main()
{
    int number;
    cout << "请输入数字number:";
    cin >> number;
    cout << "您输入的数字为：" << number << endl;
}

4、变量

• 作用：给一段指定的内存空间命名，
• 语法：数据类型 变量名 = 初始值;

5、常量

• 作用：用来记录程序中不可更改的数据，
• 语法：
  1.#define宏常量：#define 常量名 常量值;，通常在文件上方定义，表示一个常量。
  2.const修饰的变量：const 数据类型 常量名 = 常量值;，修饰该变量为常量后，不可修改。

※数据类型

C++规定在创建一个变量或常量时，必须要指定出相应的数据类型，否则无法给变量分配内存。

1、整型

• 作用：整型变量表示的是整数类型的数据。
  
  这里需要注意，取值范围指的是数值的范围，例如short取值范围就是：-32768~32767。
• 可以发现整型大小比较：short < int <= long <= long long （long类型在不同操作系统占用空间不同）

2、sizeof关键字

• 作用：利用sizeof关键字可以统计数据类型所占内存大小。
• 语法：sizeof(数据类型 / 变量);
• 例子：

#include 
using namespace std;

int main()
{
    int number = 20230112;
    cout << number << "所占内存为：" << sizeof(number) << endl;
}

3、实型（浮点型）

• 作用：用于表示小数。
  浮点型变量分为两种：1.单精度float。2.双精度double。
  
  这里需要注意，有效数值范围指的是数值中出现数字的个数，而不是小数点后数字的个数，例如3.14的有效数字范围是3，而不是2。
• 例子：由结果可以知道，输出的小数默认是6位有效数字。

#include 
using namespace std;
int main()
{

    float f1 = 3.1415926f;//末尾带f，是为了区分float，不带f，会被默认为double类型
    cout << "f1值为：" << f1 << endl;
    double d1 = 3.1415926;
    cout << "d1值为：" << d1 << endl;
}

• 补充：科学计数法

#include 
using namespace std;

int main()
{
    /*
      e后为正数a，则乘10的a次方
      e后为负数a，则乘0.1的a次方
    */

    double f1 = 2023e2;//2023*10^2 
    cout << "f1值为：" << f1 << endl;
    double f2 = 2023e-2;//2023*0.1^2
    cout << "f2值为：" << f2 << endl;
} 

4、字符型

• 作用：字符型变量用于显示单个字符。
• 语法：char ch = 'x';
• 注意：
  –1.字符用单引号括起来，不是双引号。
  –2.单引号内只能有一个字符，不可以是字符串。
  –3.C和C++中字符型变量只占1个字节。
  –4.字符型变量不是将字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元。

以字符A举例，查看对应的ASCII码。

#include 
using namespace std;

int main()
{
    char ch = 'A';
    cout << "字符'A'对应的ASCII码为：" << (int)ch << endl;
}

• 补充：ASCII码对照表。

  

5、转义字符

• 作用：用于表示一些不能显示出来的ASCII字符。
• 补充：转义字符对应表如下图，其中加粗的为最常用的转义字符。
  
  – 其中水平制表符 \t ，水平制的表占8个字节。如果有3个字符，则会生成5个空格，如果有4个字符，则会生成4个空格，例：

#include 
using namespace std;

int main() 
{
	cout << "aaa\t20230113\naaaa\t20230113";
}

6、字符串类型

• 作用：用于表示一串字符。
• 特点：string占32字节，不同库中占用大小可能不同，也有4、12、28、32字节，并且字符串所占空间是从堆中动态分配，与sizeof()无关。
• 语法：
  – 1.C语言风格：char 变量名[] = "字符串值";
  – 2.C++语言风格：string 变量名 = "字符串值";

#include 
using namespace std;

int main()
{
	//C风格字符串
	char str1[] = "20230113";
	cout << str1 << endl;
	//C++风格字符串
	string str2 = "20230113";//有时候这句会报错 需要加入头文件 #include
	cout << str2 << endl;
}

7、布尔类型

• 作用：用于表示真或假的值。
• 补充：bool类型占1个字节，值分为：true–真（本质是1），false–假（本质是0）。
• 例子：

#include 
using namespace std;

int main()
{
	bool flag1 = true;
	bool flag2 = false;
	cout << "true值为：" << flag1 << "\nfalse值为：" << flag2 << endl;
}

※运算符

• 作用：用于执行代码的运算。
• 介绍：

1、算术运算符

• 作用：用于处理四则运算。
  
• 例子：加减乘除取余

#include 
using namespace std;

int main()
{
	int number1 = 9;
	int number2 = 2;
	cout << number1 + number2 << endl;
	cout << number1 - number2 << endl;
	cout << number1 * number2 << endl;
	cout << number1 / number2 << endl;
	cout << number1 % number2 << endl;
}

– 需要注意“a / b”符号
– ①：若b为0，则分母为0，即报错；
– ②：若a，b都为整型，则结果也是整型，即整除运算（舍去小数部分），例 3 / 2 = 1 ，2 / 2 = 1 ；
– ③：若a为double类型，则结果为小数；
– ④：进阶小技巧

	使用setprecision(位数)，可以四舍五入保留指定位数有效数字。
	cout << setprecision(4)<< 3.22474 <

– 需要注意“a % b”符号
– ①：若b为0，则分母为0，即报错；
– ②：若a，b都为整型，a > b，则结果为 a / b 的余数，a < b，则结果为 a
– ③：若a为double类型，则不可做取模运算；

• 例子：前置后置递增(递减同理)

#include 
using namespace std;

int main()
{
	
	int number1 = 1;
	number1++;//等价于 number = number + 1;
	cout << number1 << endl;//结果为2

	int number2 = 1;
	++number2;
	cout << number2 << endl;//结果为2

	//前置递增 先让变量+1 然后进行表达式运算
	int number3 = 1;
	int newNumber3 = ++number3 * 10;//相当于 2*10
	cout << newNumber3 << endl;//结果为20

	//后置递增 先进行表达式运算 后让变量+1
	int number4 = 1;
	int newNumber4 = number4++ * 10;//还是 1*10 运算后 number4才变成2
	cout << newNumber4 << endl;//结果为10
}

2、赋值运算符

• 作用：用于将表达式的值赋给变量。
  
• 例子：

#include 
using namespace std;

int main()
{
	int number1 = 0;
	number1 = 10;//将10赋值给number1
	number1 += 5;//等价于 number1 = number1 + 5；
	cout << number1 << endl;
	number1 -= 5;//等价于 number1 = number1 - 5；
	cout << number1 << endl;
	number1 *= 5;//等价于 number1 = number1 * 5；
	cout << number1 << endl;
	number1 /= 5;//等价于 number1 = number1 / 5；
	cout << number1 << endl;
	number1 %= 3;//等价于 number1 = number1 % 3；
	cout << number1 << endl;
}

3、比较运算符

• 作用：用于表达式的比较，并返回一个真值和假值。
  
• 例子：

#include 
using namespace std;

int main()
{
	int number1 = 20;
	int number2 = 23;
	//中间加( )确定比较运算符的优先级
	cout << (number1 == number2) << endl; //a不等于b 所以为0
	cout << (number1 != number2) << endl;//a确实不等于b 所以为1
	cout << (number1 > number2) << endl;//a不小于b 所以为0 
	cout << (number1 < number2) << endl;//a的确小于b 所以为1
	cout << (number1 >= number2) << endl;//a不小于等于b 所以为0 
	cout << (number1 <= number2) << endl;//a的确小于等于b 所以为1
}

4、逻辑运算符

• 作用：用于根据表达式的值返回真值或假值。
  
• 例子：

#include 
using namespace std;

int main()
{
	int number1 = 2023;//在C++中 除了0都为真

	//逻辑运算符 非 ！ 真变假 假变真
	cout << !number1 << endl;// 非1 即0
	cout << !!number1 << endl;// 非非1 即 非0 即1

	//逻辑运算符 与 && 真真为真 一假则假
	cout << (number1 && 0) << endl; // 一假为假 即0
	cout << (number1 && 1) << endl; // 真真为真 即1

	//逻辑运算符 或 || 假假为假 否则为真（一个为真就为真）
	cout << (0 || 0) << endl; // 假假为假 即0
	cout << (number1 || 0) << endl; // 一真为真 即1
}

※程序流程结构

1、选择结构

• 作用：执行满足条件的语句。
• 类型：
  –1.单行格式if语句：if (条件) {条件满足执行的语句;}
  –2.多行格式if语句：if (条件) {条件满足执行的语句;} else {条件不满足执行的语句;}
  –3.多条件的if语句：if (条件1) {条件1满足执行的语句;} else if (条件2) {条件2满足执行的语句;} .... else {条件不满足执行的语句;}
  –4.三目运算符：条件 ? 条件满足执行的语句 : 条件不满足执行的语句
  –5.switch语句：switch (表达式) { case 结果1 : 执行语句 ; break; case 结果2 : 执行语句; break; ...default: 执行语句; break; }
• 例子：
  –1.选出A、B、C中的最大值（以类型1-4，进行解答）。

#include 
using namespace std;

int main()
{
	int A, B, C;
	cout << "请输入A的数值：";
	cin >> A;
	cout << "请输入B的数值：";
	cin >> B;
	cout << "请输入C的数值：";
	cin >> C;

	// 使用if嵌套 （类型前3条的嵌套使用）
	if (A == B && B == C) // A=B=C 三者相等
	{
		cout << "A、B、C值相等，都为最大值！" << endl;
	}
	else // A、B、C不同时相等
	{
		if (A > B) // A>B
		{
			if (A > C) // A>C A最大值
			{
				cout << "A为最大值！" << endl;
			}
			else if (A < C) // A
			{
				cout << "C为最大值！" << endl;
			}
			else // A=C 并列最大值
			{
				cout << "A和C都是最大值！" << endl;
			}
		}
		else   // A≤B
		{
			if (A == B) // A=B和C比较
			{
				// 使用三目运算符 （类型第4条的嵌套使用）
				cout << (B > C ? "A和B都是最大值！" : "C是最大值！") << endl;
			}
			else // A≠B 取最大值B与C进行比较
			{
				if (B == C) // B=C 并列最大值
				{
					cout << "B和C都是最大值！" << endl;
				}
				else // B≠C 
				{
					cout << (B > C ? "B为最大值！" : "C是最大值！") << endl;
				}
			}
		}
	}
}

• 补充：三目运算符也可以赋值 例：在整型abcd中，若 (a –2.给学习态度打分(以类型5，进行解答)。

#include 
using namespace std;

int main()
{
	int score;
	cout << "请给您的学习状态打分(请输入1-3之间的整数)：";
	cin >> score;
	switch (score)// 这个括号里只能输入整型或字符型，不可以是区间
	{
	case 1: // 输入的数据为1时执行下面语句
		cout << "一般般。" << endl;
		break;// 退出当前分支，若没有break，则会执行下一条语句
	case 2:
		cout << "适中吧。" << endl;
		break;
	case 3:
		cout << "很完美。" << endl;
		break;
	default:// 输入其他数据执行下面语句
		cout << "布吉岛。" << endl;
		break;
	}
}

2、循环结构

• 作用：满足循环套件，执行循环语句。
• 类型：
  –1.while循环语句：while (循环条件) { 循环语句; }
  –2.dowhile循环语句：do { 循环语句; } while (循环条件); ，dowhile先执行一次在进行循环判定。
  –3.for循环语句：for (变量表达式;条件表达式;末尾循环体) { 循环语句; }
• 例子：
  –1.猜1-100随机数游戏（while循环）。

#include 
using namespace std;

int main()
{
	srand((unsigned int)time(NULL));//添加随机数种子 利用当前时间产生随机数，防止每次随机数一样
	int number = rand() % 100 + 1;// rand()%100是产生0-99的随机数，所以+1变成1-100
	int key = 0;// 玩家输入的数值
	while (true)// 满足while()括号中的语句才会循环，这里利用true无限循环
	{
		cout << "请输入1-100的整数：";
		cin >> key;
		if (key > number)
		{
			cout << "您输入的数字太大啦！\n" << endl;
		}
		else if (key < number)
		{
			cout << "您输入的数字太小啦！\n" << endl;
		}
		else
		{
			cout << "恭喜您猜对啦！！！" << endl;
			break;// 跳出当前循环
		}
	}
}

• 补充：若添加随机数种子时，time报错 可以在头文件中添加 #include
  –2.水仙花数（do…while循环）。

#include 
using namespace std;

int main()
{
	// 水仙花数是指一个3位数，它的每个位上的数字的3次方之和等于他本身
	int a, b, c; // 用来代替三位数的百位、十位、个位
	int number = 100; // 三位数即 100 - 999
	cout << "水仙花数为：" << endl;
	do
	{
		a = number / 100; // 百位
		b = number / 10 % 10; // 十位
		c = number % 10; // 个位
		if (number == a * a * a + b * b * b + c * c * c) // 判定条件
		{
			cout << number << endl;
		}
		number++;
	} while (number < 1000);
}

–3.敲桌子游戏（for循环）。

#include 
using namespace std;

int main()
{
	//从编号1-100内，选出十位、个位为7和7的倍数的编号，进行敲桌子。
	cout << "敲桌子的编号为：" << endl;
	for (int i = 1; i <= 100; i++)
	{
		if (i / 10 == 7 || i % 10 == 7 || i % 7 == 0)
		{
			cout << i << endl;
		}
	}
}

3、跳转语句

• 类型：

–1.break语句：用于跳出选择结构或者循环结构。

使用时机：
1.出现在switch语句中，作用是终止case并跳出switch。
2.出现在循环语句中，作用是跳出当前的循环语句。
3.出现在嵌套循环中，作用是跳出最近的内层循环语句。
（↑上文中出现过例子，不再进行举例。）

–2.continue语句：在循环语句中，跳过本次循环，执行下次循环。

#include 
using namespace std;

int main()
{
	for (int i = 0; i < 10; i++)
	{
		if (i == 5)//当i为5时，跳过本次循环，即不输出5
		{
			continue;
		}
		cout << i << " ";
	}
	cout << endl;
}

–3.goto语句：可以无条件跳转语句。语法：goto 标记;
如果标记的名称存在，则在执行到goto语句时，会跳转到标记的位置。

#include 
using namespace std;

int main()
{
	cout << "1" << endl;
	cout << "2" << endl;
	goto FLAG; // 标记名一般命名为全大写。
	cout << "3" << endl;
FLAG: // 执行到上方goto语句时，将跳到这里的指定标记处 即跳过"3"的输出。
	cout << "4" << endl;
}

※数组

• 概述：一个存放相同类型的数据元素集合。
• 特点：1.数组每个数据元素的数据类型相同。2.数组是由连续的内存位置组成。

1、一维数组定义

• 定义：
  –1.数据类型 数据名[ 数组长度 ];
  –2.数据类型 数据名[ 数组长度 ] = { 值1,值2.... };
  –3.数据类型 数据名[ ] = { 值1,值2.... };
• 例子：

 #include 
using namespace std;

int main()
{
	// 1、数据类型 数据名[ 数组长度 ];
	int arr1[3];
	arr1[0] = 0;
	arr1[1] = 1;
	arr1[2] = 2;
	cout << arr1[1] << endl;

	// 2、数据类型 数据名[数组长度] = { 值1,值2.... }; 
	int arr2[3] = { 0,1 }; 
	for (int i = 0; i < 3; i++)
	{
		cout << arr2[i] << endl; // 若数组中元素个数小于数组长度，则剩下的位置会被0填补。
	}

	// 3、数据类型 数据名[] = { 值1,值2.... }; 
	int arr3[] = { 1,0 }; // 数组个数未填写时，数组会自己检测数组个数，即2个。
	for (int i = 0; i < sizeof(arr3) / sizeof(arr3[0]); i++) //end(arr3)-begin(arr3)也可以计算数组arr3的长度
	{
		cout << arr3[i] << endl;
	}
}

2、一维数组数组名

• 用途：
  – 1.统计整个数组在内存的长度。sizeof( arr );
  – 2.统计第一个元素在内存的长度。sizeof( arr[0] );
  – 3.获取数组的元素个数。sizeof( arr ) / sizeof( arr[0] );
  – 4.获取数组在内存中的首地址。cout << arr << endl;
  – 5.获取数组在内存中首地址的十进制。cout << (int) arr << endl;
  – 6.获取元素在内存中的首地址。cout << &arr[0] << endl;
• 补充：
  – 1.取元素在内存中的地址，需要使用取址符&，获取地址。
  – 2.数组名是常数，无法直接赋值。
• 例子：将数组元素倒置，例1,2,3,4,5倒置变成5,4,3,2,1。

#include 
using namespace std;

int main()
{
	/*
		思路：1、2、3、4倒置，只需要将1,4对换，2,3对换即可，
			 即第一位与倒数第一位，第二位与倒数第二位交换...第n位与倒数第n位交换。
			 当第n位的下标，大于等于倒数第n位的下标时，交换完毕，停止交换。
	*/
	int arr[] = { 1,5,3,2,4 };
	int temp = 0; // 用来做临时储存数组元素的容器
	int length = sizeof(arr) / sizeof(arr[0]); // 数组元素的个数
	int start = 0; // 倒置时做临时初始下标（倒置操作前者）
	int end = length - 1; // 倒置时做临时末尾下标（倒置操作后者）
	cout << "原数组为：";
	for (int i = 0; i < length; i++) // 打印原数组 
	{
		cout << arr[i] << " ";
	}
	cout << "\n倒置后的数组为：";

	while (start < end) // 将数组倒置
	{
		temp = arr[end]; // 临时容器记录正在进行倒置操作的后者
		arr[end] = arr[start]; // 将数组准备倒置的前者赋值给后者
		arr[start] = temp; // 将临时容器记录的值 给数组准备倒置的前者
		start++; // 将数组准备倒置的前者向后移动一位
		end--; // 将数组准备倒置的后者向前移动一位
	}

	for (int i = 0; i < length; i++) // 和上面打印数组一样 （其实数组打印的语法重复，写成方法调用更好）
	{
		cout << arr[i] << " ";
	}
}

• 难·例子：利用冒泡排序给已知数组元素升序。

#include
using namespace std;

int main()
{
    /*
        思路：冒泡排序原理，是比较相邻的元素。如果第一个比第二个大，就交换它们两个。
			  对每一对相邻的元素进行同样的工作，执行完毕后，找到第一个最大值。
			  随后对剩下的元素，重复以上的步骤，每次比较次数-1﹐直至排列完成，不需要比较。
    */
    int arr[] = { 4,2,8,7,9,1,6,3,5 };
    int temp = 0; // 用来做临时储存数组元素的容器
    int length = sizeof(arr) / sizeof(arr[0]); // 数组元素的个数
    int start = 0; // 倒置时做临时初始下标（倒置操作前者）
    int end = 1; // 倒置时做临时末尾下标（倒置操作后者）
    cout << "冒泡排序前的数据为：";
    for (int i = 0; i < length; i++) {
        cout << arr[i] << " ";
    }

    for (int i = 1; i < length; i++) // 元素共需进行n-1次冒泡排序 得出结果
    {
        for (int j = 0; j < 9 - i; j++) // 第n次排序进行9-n次交换
        {
            if (arr[start] >= arr[end]) // 若前面元素的大于等于后面元素，则发生交换
            {
                temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
            start++;
            end++; // 将需要交换的元素下标下移
        }
        start = 0;
        end = 1; // 将记录元素临时下标初始化
    }

    cout << "\n冒泡排序后的数据为：";
    for (int i = 0; i < 9; i++) {
        cout << arr[i] << " ";
    }
}

3、二维数组定义

• 类型：
  – 1.数据类型 数据名 [ 行数 ] [ 列数 ];
  – 2.数据类型 数据名 [ 行数 ] [ 列数 ] = { {数据1 , 数据2} , {数据3 , 数据4} };
  – 3.数据类型 数据名 [ 行数 ] [ 列数 ] = { 数据1 , 数据2 , 数据3 , 数据4 };
  – 4.数据类型 数据名 [ ] [ 列数 ] = { 数据1 , 数据2 , 数据3 , 数据4 };
• 例子：

#include
using namespace std;

//每次打印太麻烦，写个方法调用，后面会写章《C++高级篇文章》讲解 
void print(int arr[2][3]) 
{
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}
}

int main()
{
	//数据类型 数据名 [ 行数 ] [ 列数 ];
	int arr1[2][3];
	arr1[0][0] = 1;
	arr1[0][1] = 2;
	arr1[0][2] = 3;
	arr1[1][0] = 4;
	arr1[1][1] = 5;
	arr1[1][2] = 6;
	print(arr1);

	//数据类型 数据名 [ 行数 ] [ 列数 ] = { {数据1 , 数据2} , {数据3 , 数据4} };
	int arr2[2][3] = { {1,2,3},{4,5,6} };
	print(arr2);

	//数据类型 数据名 [ 行数 ] [ 列数 ] = { 数据1 , 数据2 , 数据3 , 数据4 };
	int arr3[2][3] = { 1,2,3,4,5,6 };
	print(arr3);

	//数据类型 数据名[][列数] = { 数据1 , 数据2 , 数据3 , 数据4 };
	int arr4[][3] = { 1,2,3,4,5,6 };
	print(arr4);
}

4、二维数组数组名

• 用途：
  – 1.查看二维数组所占内存空间。sizeof( arr );
  – 2.查看二维数组第一行所占内存空间。sizeof( arr[0] );
  – 3.查看二维数组第一个元素所占内存空间。sizeof( arr[0][0] );
  – 4.查看二维数组行数。sizeof( arr ) / sizeof( arr[0] );
  – 5.查看二维数组列数。sizeof( arr[0] ) / sizeof( arr[0][0] );
  – 5.查看二维数组元素个数。sizeof( arr ) / sizeof( arr[0][0] );
  – 6.获取二维数组首地址。cout << arr << endl;
  – 7.获取二维数组首地址的十进制。cout << (int) arr << endl;
  – 8.获取二维数组第一行的首地址。cout << arr[0] << endl;
  – 9.获取二维数组第一个元素的首地址。cout << &arr[0][0] << endl;
• 例子：
  

#include
using namespace std;

int main()
{
	int score[][3] = { {100,100,100} ,{90,50,100} ,{60,70,80} };//创建学生成绩数组
	int sum = 0;
	int tempScore[3];
	for (int i = 0; i < (sizeof(score) / sizeof(score[0])); i++)
	{
		for (int j = 0; j < (sizeof(score[0]) / sizeof(score[0][0])); j++)
		{
			sum += score[i][j];//得到每一行之和
		}
		tempScore[i] = sum;
		sum = 0;//初始化sum
	}
	cout << "张三总成绩为：" << tempScore[0] << endl;
	cout << "李四总成绩为：" << tempScore[1] << endl;
	cout << "王五总成绩为：" << tempScore[2] << endl;
}

※函数

• 概述：将一段经常使用的代码封装起来，减少重复代码。
• 补充：一个较大的程序，一般分为若干个程序块，每个模块实现特定的你功能。

1、函数定义

• 函数的定义一般主要有5个步骤：
  – 1、返回值类型
  – 2、函数名
  – 3、参数表列
  – 4、函数体语句
  – 5、return 表达式
• 语法：

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

2、函数调用

使用定义好的函数。

• 语法：函数名 (参数)
• 例子：调用求两数之和的函数

#include
using namespace std;

int sum(int num1, int num2)//num1,num2没有真实数据，是个形参
{
	int sum = num1 + num2;
	return sum;
}

int main()
{
	int a = 2022;//a,b是真实存在的，是实参
	int b = 1;
	cout << sum(a, b) << endl;
}

3、值传递

值传递就是在函数调用时实参将数值传给形参，值传递时，如果形参发生改变，不会影响实参。

• 例子：交换两数值，改变形参时，实参不发生改变。

#include
using namespace std;

//函数不需要返回值，声明时可以使用void
void swap(int num1, int num2)//num1,num2没有真实数据，是个形参
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
	cout << "形参交换后：a=" << num1 << ",b=" << num2 << endl;
	//返回值不需要时，可以不写return
}

int main()
{
	int a = 2022;//a,b是真实存在的，是实参
	int b = 2023;
	cout << "实参交换前：a=" << a << ",b=" << b << endl;
	swap(a, b);
	cout << "实参交换后：a=" << a << ",b=" << b << endl;
}

4、函数声明

• 作用：告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
• 注意：函数的声明可以多次，但是函数的定义只能有一次！
• 例子：

#include
using namespace std;

void swap(int num1, int num2);//函数声明，不写函数体，（可以写多个声明）

int main()
{
	int a = 2022;//a,b是真实存在的，是实参
	int b = 2023;
	swap(a, b);//调用函数，若前面没有声明函数，运行时会报错
}

void swap(int num1, int num2)//在调用函数后面写函数的话，要提前声明，不然报错（只能有一个定义）
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
	cout << "交换后：a=" << num1 << ",b=" << num2 << endl;
}

5、函数分文件编写

• 作用：让代码结构更清晰。
• 步骤：
  – 1.创建后缀名为.h的头文件，在头文件中写函数的声明。(记得引用C++必带内容)
  – 2.创建后缀名为.cpp的源文件，在源文件中写函数的定义。(记得引用步骤1中定义的头文件)
  – 3.在需要使用相关函数的源文件中，引用步骤1中的头文件，即可使用头文件声明过的函数。
• 例子：以上节的两数交换函数为例，分文件编写。

1.在头文件中创建swap.h头文件，并在头文件中写swap函数的声明。
(函数可以写多个的，这里只是用swap命名，用其他命名和其他函数均不影响结果。)

#include //这两行是C++必带内容
using namespace std;

void swap(int num1, int num2);//函数声明

2.在源文件中创建swap.cpp源文件，并在源文件中写swap函数的定义。

#include "swap.h";// " " 代表自定义的头文件，引用之后，对应的源文件和头文件建立联系

void swap(int num1, int num2)//这里写了声明过的函数定义
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
	cout << "交换后：a=" << num1 << ",b=" << num2 << endl;
}

3.在要使用相关函数的源文件中，引用头文件后，直接调用声明过的函数。

#include
#include "swap.h"; //引用自定义的头文件 下面可以直接调用头文件中声明过的相关函数
using namespace std;

int main()
{	
	int a = 2022;
	int b = 2023; 
	swap(a, b);//直接使用被定义过的函数
}

※指针

• 作用：通过指针可以间接访问内存。
• 补充：
  – 1. 内存编号是从0开始记录的，一般用十六进制数字表示。
  – 2. 可以利用指针变量保存地址。

1、指针变量的定义和使用

• 指针变量定义语法：数据类型 * 变量名p;
• 指针指向变量a地址：变量名p = & 变量名a; （指针p，代表变量a的地址）
• 指针修改变量a的值：* 变量名p = 数值; （“ *指针”是解引用，代表指针指向地址中的值，即变量a的值）
• 例子：

#include
using namespace std;

int main()
{	
	int a = 2022;
	int* p; //定义指针变量p
	p = &a; //让指针p记录a的地址
	//上面两行，等价于 int* p = &a;
	cout << "a的地址为：" << p << endl; // 此时指针p为a的地址
	*p = 2023;// *p表示解引用 ，即指针p指向内存中的数据（变量a的数据）
	cout << "a的值为：" << a << endl;// 此时变量a的值，已通过指针解引用修改
}

2、指针所占的内存空间

• 32位系统：所有数据类型都是占4个字节。
• 64位系统：所有数据类型都是占8个字节。
• 想查看时候的语法：cout << sizeof(int *) << endl;
  或者：cout << sizeof(p) << endl; (前提是指针名为p，即定义 int * p;)

3、空指针

• 定义：指针变量指向内存中编号为0的空间。
• 用途：初始化指针变量。
• 注意：空指针指向的内存是不可以访问的。
  （0~255之间的内存编号是系统占用的，因此不可以访问。）
• 语法：int * p = NULL;

4、野指针

• 定义：指针变量指向非法的内存空间。
• 注意：程序中要避免出现这种情况。
• 语法：int * p = (int *) 0x1100;（这里0x1100只是随便输入的，未被申请的地址例子。）

5、const修饰指针

• const修饰指针有三种情况：
  – 1. const修饰指针。 ——常量指针
  语法：const int * p = &a;
  特点：指针指向可以修改(可以指向其他地址，例p = &b)，但是不可以修改指针指向的值。
  – 2. const修饰常量。 ——指针常量
  语法：int * const p = &a;
  特点：指针指向不可以修改，但是可以修改指针指向的值(例 * p=2023)。
  – 3. const即修饰指针，又修饰常量。
  语法：const int const * p = &a;
  特点：指针指向以及指针指向的值，都不可修改。
• 例子：

#include
using namespace std;

int main()
{
	int a = 2022;
	int b = 2023;

	const int* p1 = &a;//常量指针
	cout << "p1指针指向a地址的值为：" << *p1 << endl;
	p1 = &b;//指针指向可以修改，但不能修改指针指向的值
	cout << "p1修改指针指向b地址的值后为：" << *p1 << endl << endl;

	int* const p2 = &a;//指针常量
	cout << "p2指针指向a地址的值为：" << *p2 << endl;
	*p2 = 2024;//指针指向不可以修改，但是可以修改指针指向的值
	cout << "修改p2指针所指向的a地址值后为：" << *p2 << endl << endl;

	const int* const p3 = &a;//const修饰指针，又修饰常量
	cout << "p3指针的指向和指向的值都不可修改，均为a地址的值：" << *p3 << endl;
}

6、指针和数组

• 作用：利用指针访问数组元素。
• 例子：

#include
using namespace std;

int main()
{
	int arr[] = { 1,2,3,4 };
	int* p = arr;//令指针指向arr，arr就是数组的首地址
	for (int i = 1; i < 5; i++) {
		cout << "数组第" << i << "个元素为：" << *p << endl;
		p++;//让指针向后偏移4个字节 (int是4个字节，其他类型就偏移对应个字节)
	}
}

7、指针和函数

• 作用：利用指针作函数参数，可以修改实参的值。
• 例子：

#include
using namespace std;

void swap(int* p1, int* p2)//用指针作形参
{
	int temp = *p1;
	*p1 = *p2;//指针p1指向的地址里的值，已被修改成了指针p2指向地址里的值
	*p2 = temp;
}

int main()
{
	int a = 2022;
	int b = 2023;
	cout << "交换前，a的值为：" << a << " ，b的值为：" << b << endl;
	swap(&a, &b);//函数应填实参的地址
	cout << "交换后，a的值为：" << a << " ，b的值为：" << b << endl;
}

• 难·例子：利用冒泡排序给已知数组元素升序。

#include
using namespace std;

void bubbleSort(int* arr, int length)//用指针作形参 传过来的是arr数组的首地址 函数里可以当数组直接用
{
	int temp = 0;
	for (int i = 1; i < length; i++) //冒泡排序(长度-1)轮
	{
		for (int j = 0; j < length - i; j++) //第i轮 交换(长度-i)次元素
		{
			if (arr[j] > arr[j + 1]) //如果 前者>后者 交换位置
			{
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

void printArray(int* arr, int length)//打印数组
{
	for (int i = 0; i < length; i++)
	{
		cout << arr[i] << " ";
	}
}

int main()
{
	int arr[] = { 7,2,4,9,1,5,8,0,6,3 };
	int length = sizeof(arr) / sizeof(arr[0]);
	cout << "原数组为：";
	printArray(arr, length);
	bubbleSort(arr, length);
	cout << "\n冒泡排序后，数组为：";
	printArray(arr, length);
}

※结构体

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

1、结构体定义和使用

• 创建结构体(类)语法：struct 结构体名(数据类型) { 结构体成员列表 };
• 通过结构体创建变量的方式有三种：
  – 1. struct 结构体名 变量名
  – 2. struct 结构体名 变量名 = { 成员1值 , 成员2值.... }
  – 3. 定义结构体时顺便创建变量
• 例子：

#include
using namespace std;

struct Student // 创建学生数据类型
{
	//成员列表
	string name;
	int age, score;
}s3; // 带这个s3，是第三种创建变量方式：(定义结构体时顺便创建变量)，在main函数里直接引用赋值就行

int main()
{
	// 第一种创建变量方式：(struct 结构体名 变量名)，在给变量赋值
	struct Student s1;
	s1.name = "摸鱼王";
	s1.age = 20;
	s1.score = 100;
	cout << "姓名：" << s1.name << " 年龄：" << s1.age << " 分数：" << s1.score << endl;

	// 第二种创建变量方式：(struct 结构体名 变量名 = { 成员1值 , 成员2值.... })
	struct Student s2 = {"无敌停",23,100};// 这个元素不填写完整可能会报错
	cout << "姓名：" << s2.name << " 年龄：" << s2.age << " 分数：" << s2.score << endl;

	// 第三种，看创建学生类的结构体末端注释。
	s3.name = "暴龙兽";
	s3.age = 99;
	s3.score = 100;
	cout << "姓名：" << s3.name << " 年龄：" << s3.age << " 分数：" << s3.score << endl;
}

• 补充：
  – 1. 输出时，若s1.name(输出string类型)报错，加头文件#include 即可。
  – 2. 在结构体创建变量时，struct关键字可以省略，但在创建结构体时不可省略。

2、结构体数组

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

#include
using namespace std;

struct Student // 创建学生数据类型
{
	string name;
	int age, score;
};

int main()
{
	// 创建结构体数组
	struct Student stuArray[] = { {"摸鱼王",20,100},{"无敌停",23,100},{"暴龙兽",99,100} };

	// 给结构体数组中的元素，某一项赋值
	stuArray[2].name = "摸鱼停";

	// 遍历
	for (int i = 0; i < sizeof(stuArray) / sizeof(stuArray[0]); i++)
	{
		cout << "姓名：" << stuArray[i].name << " 年龄：" << stuArray[i].age << " 分数：" << stuArray[i].score << endl;
	}
}

3、结构体指针

• 作用：通过指针访问结构体中的成员。
• 语法：利用操作符->，可以通过结构体指针访问结构体属性。
• 例子：

#include
using namespace std;

struct Student // 创建学生数据类型
{
	string name;
	int age, score;
};

int main()
{
	// 创建结构体变量
	Student stu1 = { "摸鱼王",20,100 };

	// 通过指针指向结构体变量
	Student* p = &stu1;

	//通过指针访问结构体变量中的数据
	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}

4、结构体嵌套结构体

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

#include
using namespace std;

struct Student // 创建学生数据类型
{
	string name;
	int age, score;
};

struct Teacher // 创建教师数据类型
{
	string name;
	int age;
	Student stu;// 子结构体 学生
};

int main()
{
	Teacher teacher = {"摸鱼王",50,"停停",22,100};
	//调用子结构的变量 （结构变量名.子结构变量名.子结构成员变量名）
	cout << "教师姓名：" << teacher.name << " 教师年龄：" << teacher.age << " 辅导学生：" << teacher.stu.name 
		<< " 学生年龄：" << teacher.stu.age << " 学生分数：" << teacher.stu.score << endl;
}

5、结构体做函数参数

• 作用：将结构体作为参数向函数中传递。
• 传递方式有两种：
  – 1. 值传递 （函数体中修改形参，不影响实参的值）
  – 2. 地址传递（函数体中修改形参，影响实参的值）
• 例子：

#include
using namespace std;

struct Student // 创建学生数据类型
{
	string name;
	int age, score;
};

void printStudent1(Student stu) // 值传递 
{
	stu.age = 22;
	cout << "值传递打印数据→姓名：" << stu.name << " 年龄：" << stu.age << " 分数：" << stu.score << endl;
}

void printStudent2(Student* p) // 地址传递
{
	p->age = 23;
	cout << "地址传递打印数据→姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}


int main()
{
	Student student = { "摸鱼王",20,100 };
	cout << "原始数据中，stu的age值为：" << student.age << endl << endl;
	printStudent1(student);
	cout << "值传递中修改变量，不改变实参的值，即当前地址中stu的age仍为初始值：" << student.age << endl << endl;
	printStudent2(&student);
	cout << "地址传递中修改变量，会改变实参的值，即当前地址中stu的age更新为：" << student.age << endl << endl;
}

6、结构体中const使用场景

• 作用：用const来防止误操作。
• 例子：

#include
using namespace std;

struct Student // 创建学生数据类型
{
	string name;
	int age, score;
};

// 用地址传递(指针) 可以减少内存空间，而且不会赋值新的副本 
void printStudent1(const Student * stu) // const修饰指针，即常量指针，不可修改stu的值
{
	// s->age="23"; 此时这句话会报错，因为常量指针不可修改值，防止用户误操作进行提醒 
	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;
}

int main()
{
	Student student = { "摸鱼王",20,100 };
	printStudent1(&student);
}

7、结构体综合例题

• 例子1：
  

#include
using namespace std;

struct Student // 创建学生数据类型
{
	string name; 
	int score;
};

struct Teacher // 创建教师数据类型
{
	string name;
	Student array[5];
};

void assignment(Teacher  teacher[], int length) // 给教师和学生信息赋值
{
	string nameTeacher = "ABCDEF";
	string nameStudent = "abcdef";
	for (int i = 0; i < length; i++) {
		teacher[i].name = "teacher_";
		teacher[i].name += nameTeacher[i];// 第i个教师名为 teacher_ 和 ABCD中第i个字母拼接
		for (int j = 0; j < (sizeof(teacher[i].array) / sizeof(teacher[i].array[0])); j++) // 给老师对应的学生赋值
		{
			teacher[i].array[j].name = "student_";
			teacher[i].array[j].name += nameTeacher[i]; // 给学生姓名赋予老师的尾号
			teacher[i].array[j].name += nameStudent[j]; // 给学生姓名赋予学生专属尾号
			int random = rand() % 40 + 60; // 产生0~40的随机数 + 60 即 60~100的随机数
			teacher[i].array[j].score = random;
		}
	}
}

void printInfo(Teacher teacher[], int length) // 打印教师和学生信息
{
	for (int i = 0; i < length; i++)
	{
		cout << "第" << (i + 1) << "个教师名为：" << teacher[i].name << endl;
		cout << "培养的学生名字和成绩分别为：";
		for (int j = 0; j < (sizeof(teacher[i].array) / sizeof(teacher[i].array[0])); j++)
		{
			cout << teacher[i].array[j].name << " " << teacher[i].array[j].score << " ";
		}
		cout << endl; // 打印完一个教师和学生信息 换行
	}
}

int main()
{
	//↓这步随机数种子如果报错 需要在头文件中添加 #include  详细如第四章循环结构例题
	srand((unsigned int)time(NULL));//添加随机数种子 为学生每次产生不同的随机数成绩做准备
	Teacher teacher[3]; // 创建教师数组
	int length = sizeof(teacher) / sizeof(teacher[0]); // 获取教师数组长度(不要直接用3 养成好习惯)
	assignment(teacher, length); // 调用教师赋值函数
	printInfo(teacher, length); // 调用打印信息函数
}

• 例子2：
  

#include
using namespace std;

struct Hero // 创建英雄数据类型
{
	string name;
	int age;
	string sex;
};

void bubbleSort(Hero heroArray[], int length) // 冒泡排序
{
	for (int i = 1; i < length; i++) // 冒泡排序轮数 
	{
		for (int j = 0; j < length - i; j++) // 每轮冒泡交换次数
		{
			if (heroArray[j].age <= heroArray[j + 1].age)
			{
				Hero temp = heroArray[j]; // 创建新对象保存当前数组中对象的信息
				heroArray[j] = heroArray[j + 1]; // 将数组交换，等同所有元素交换
				heroArray[j + 1] = temp;
			}
		}
	}
}

void printInfo(Hero heroArray[], int length) // 打印数据
{
	for (int i = 0; i < length; i++) // 冒泡排序轮数 
	{
		cout << "姓名：" << heroArray[i].name << " 年龄：" << heroArray[i].age << " 性别：" << heroArray[i].sex << endl;
	}
}

int main()
{
	Hero heroArray[5] = { {"小赵",22,"男"},{"小张",21,"男"},{"小李",22,"女"},{"小孟",23,"女"},{"小天",20,"男"} };
	int length = sizeof(heroArray) / sizeof(heroArray[0]);
	cout << "初始数据：" << endl;
	printInfo(heroArray, length); // 调用打印数据函数
	bubbleSort(heroArray, length); // 调用冒泡排序函数
	cout << "冒泡排序后数据：" << endl;
	printInfo(heroArray, length); // 调用打印数据函数
}

---

终于把《黑马程序员》的C++课程基础笔记更新完啦，做两天例题休息休息。然后更新剩下的高级篇内容（内存、引用、重载、封装、继承、多态、文件操作），如果今年研究生上岸，后续更新进阶笔记（模板、容器、算法），嘻嘻，祝大家代码写的越来越好，下线下线。