• C++学习记录3

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

    文章目录

    前言

    接前文 C++学习记录2

    提示：以下是本篇文章正文内容，下面案例可供参考

    五、数组

    5.1 概述

    在这里插入图片描述

    5.2 一维数组

    5.2.1 一维数组的定义方式

    一维数组的三种定义方式：

    1. 数据类型 数组名[ 数组长度 ]；
    2. 数据类型 数组名[ 数组长度 ] = { 值1，值2，… }；
    3. 数据类型 数组名[ ] = { 值1，值2，… }；

    `数组特点：

    • 放在一块连续的内存空间中；
    • 数组(array)中每个元素都是相同数据类型。
      在这里插入图片描述
      在这里插入图片描述
      如果在初始化数据的时候，没有全部填写完，会用0来填补剩余数据
      在这里插入图片描述
    #include
using namespace std;

int main() {

	//数组

	/*
	 1. 数据类型  数组名[ 数组长度 ]；
	 2. 数据类型  数组名[ 数组长度 ] = { 值1，值2，... }；
	 3. 数据类型  数组名[  ] = { 值1，值2，... }；
	*/

	//1. 数据类型  数组名[ 数组长度 ]
	int arr[5];
	//给数组中的元素进行赋值
	//数组元素的下标是从0开始索引的
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;

	//访问数据元素

	//cout << arr[0] << endl;
	//cout << arr[1] << endl;
	//cout << arr[2] << endl;
	//cout << arr[3] << endl;
	//cout << arr[4] << endl;


	//2. 数据类型  数组名[数组长度] = { 值1，值2，... }；
	//如果在初始化数据的时候，没有全部填写完，会用0来填补剩余数据
	int arr2[5] = { 10,20,30 };

	//cout << arr2[0] << endl;
	//cout << arr2[1] << endl;
	//cout << arr2[2] << endl;
	//cout << arr2[3] << endl;
	//cout << arr2[4] << endl;
	//利用循环 输出数组中的元素

	for (int i = 0; i < 5; i++)
	{
		cout << arr2[i] << endl;
	}

	//3. 数据类型  数组名[  ] = { 值1，值2，... }；
	//定义数组的时候，必须有初始长度
	int arr3[] = { 90,80,70,60,50,40,30,20,10 };
	for (int i = 0; i < 9; i++)
	{
		cout << arr3[i] << endl;
	}
	
	system("pause");

	return 0;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61

    总结1：数组名的命名规范与变量名命名规范一致，不要和变量名重名
    总结2：数组中下标是从0开始索引

    5.2.2一维数组数组名

    一维数组名称的用途：

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

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    #include
using namespace std;

int main() {

	//数组名用途
	// 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 << "数组首地址为：" << arr << endl;//16进制表示
	cout << "数组首地址为：" << (int)arr << endl;//10进制表示
	cout << "数组中第一个元素的地址为：" << (int)&arr[0] << endl;
	cout << "数组中第二个元素的地址为：" << (int)&arr[1] << endl;

	//数组名是常量，不可以进行赋值
	//arr = 100;

	system("pause");

	return 0;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

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

    案例描述：

    • 在一个数组中记录了五只小猪的体重，如：int arr[5] = {300,350,200,400,250}
    • 找出并打印最重的小猪体重

    在这里插入图片描述

    #include
using namespace std;

int main() {

	//1、创建5只小猪体重的数组
	int arr[5] = { 300,350,200,400,250 };
	//2、从数组中找到最大值
	int max = 0;  //先认定一个最大值
	for (int i = 0; i < 5; i++)
	{
		//cout << arr[i] << endl;
		//如果访问的数组中的元素比我认定的最大值还大，更新最大值
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}
	//3、打印最大值
	cout << "最重的小猪体重为：" << max << endl;
	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    练习案例2：数组元素逆置

    • 案例描述:请声明一个5个元素的数组，并且将元素逆置.
    • (如原数组元素为:1,3,2,5.4;逆置后输出结果为:4,5,2,3,1);

    在这里插入图片描述

    #include
using namespace std;

int main() {

	//实现数组元素逆置

	//1、创建数组
	int arr[5] = { 1,3,2,5,4 };
	cout << "数组逆置前：" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}
	//2、实现逆置
	//2.1记录起始下标位置
	//2.2记录结束下标位置
	//2.3起始下标与结束下标的元素互换
	//2.4起始位置++， 结束位置--
	//2.5循环执行2.1操作，直到起始位置 >= 结束位置
	int start = 0;//起始下标
	int end = sizeof(arr) / sizeof(arr[0])-1; //结束下标

	while (start < end)
	{
		//实现元素互换
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;

		//下标更新
		start++;
		end--;
	}
	//3、打印逆置后的数组
	cout << "数组元素逆置后：" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout<< arr[i]<<endl;
	}

	system("pause");
	return 0;
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    5.2.3 冒泡排序

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

    1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
    3. 重复以上的步骤，每次比较次数-1，直到不需要比较
      在这里插入图片描述在这里插入图片描述
      在这里插入图片描述
    #include
using namespace std;

int main() {

	//利用冒泡排序实现升序排序
	int arr[9] = { 4,2,8,0,5,7,1,3,9 };
	cout << "排序前数组为：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << " ";//" "空格
	}
	cout << endl;

	//开始冒泡排序
	//总排序轮数为 元素个数 - 1
	for (int i = 0; i < 9 - 1; i++)
	{
		//内层循环对比  次数 = 元素个数 - 当前轮数 - 1
		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 << "排序后数组为：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    5.3 二维数组

    二维数组就是在一维数组上，多加了一个维度

    5.3.1 二维数组的定义方式

    二维数组定义的四种方式:

    1. 数据类型数组名[行数][列数];
    2. 数据类型数组名[行数][列数] = { {数据1，数据2}，{数据3，数据4 } };
    3. 数据类型﹐数组名[行数][列数] = {数据1，数据2，数据3，数据4};
    4. 数据类型数组名[][列数] = {数据1，数据2，数据3，数据4};
    建议:以上4种定义方式，利用第二种更加直观，提高代码的可读性 
    #include
using namespace std;

int main() {

	//二维数组的定义方式
	/*
	1. 数据类型数组名[行数][列数];
	2. 数据类型数组名[行数][列数] = { {数据1，数据2}，{数据3，数据4 } };
	3. 数据类型﹐数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
	4. 数据类型数组名[][列数] = { 数据1，数据2，数据3，数据4 };
	*/
	//1. 数据类型数组名[行数][列数];
	int arr[2][3];
	arr[0][0] = 1;
	arr[0][1] = 2;
	arr[0][2] = 3;
	arr[1][0] = 4;
	arr[1][1] = 5;
	arr[1][2] = 6;
	//输出二维数组
	/*cout << arr[0][0] << endl;
	cout << arr[0][1] << endl;
	cout << arr[0][2] << endl;
	cout << arr[1][0] << endl;
	cout << arr[1][1] << endl;
	cout << arr[1][2] << endl;*/

	//外层循环打印行数，内层循环打印列数
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << endl;
		}
	}

	//2. 数据类型数组名[行数][列数] = { {数据1，数据2}，{数据3，数据4 } };
	int arr2[2][3] = 
	{
		{1,2,3},
		{4,5,6}
	};
	cout << "输出第二种方式定义的数组" << endl;
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr2[i][j] << " ";
		}
		cout << endl;
	}

	//3. 数据类型﹐数组名[行数][列数] = { 数据1，数据2，数据3，数据4 };
	int arr3[2][3] = { 1,2,3,4,5,6 };
	cout << "输出第三种方式定义的数组" << endl;
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr3[i][j] << " ";
		}
		cout << endl;
	}
	//4. 数据类型数组名[][列数] = { 数据1，数据2，数据3，数据4 };
	int arr4[][3] = { 1,2,3,4,5,6 };
	cout << "输出第四种方式定义的数组" << endl;
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr3[i][j] << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81

    5.3.2 二维数组数组名

    • 查看二维数组所占内存空间
    • 获取二维数组首地址
    #include
using namespace std;

int main() {

	//二维数组名称用途

	//1、查看二维数组所占内存空间
	int arr[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};
	cout << "二维数组占用内存空间为：" << sizeof(arr) << endl;
	cout << "二维数组第一行占用内存空间为：" << sizeof(arr[0]) << endl;
	cout << "二维数组第一个元素占用内存空间为：" << sizeof(arr[0][0]) << endl;
	
	cout << "二维数组行数为：" << sizeof(arr) / sizeof(arr[0]) << endl;
	cout << "二维数组列数为：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;

	//2、获取二维数组首地址
	cout << "二维数组的首地址为：" << (int)arr << endl;
	cout << "二维数组的第一行首地址为：" << (int)arr[0] << endl;
	cout << "二维数组的第二行首地址为：" << (int)arr[1] << endl;

	cout << "二维数组的第一个元素的首地址为：" << (int)&arr[0][0] << endl;
	cout << "二维数组的第二个元素的首地址为：" << (int)&arr[0][1] << endl;

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    5.3.3 二维数组应用案例

    1
    在这里插入图片描述

    输出字符串（string）类型时，需要包含头文件

    在这里插入图片描述

    #include
using namespace std;
#include

int main() {

	//二维数组案例-考试成绩统计

	//1、创建二维数组
	int scores[3][3] =
	{
		{100,100,100},
		{90,50,100},
		{60,70,80}
	};

	string names[3] = { "张三","李四","王五" };

	//2、统计每个人的总和分数
	for (int i = 0; i < 3; i++)
	{
		int sum = 0;//统计分数总和变量
		for (int j = 0; j < 3; j++)
		{
			//sum = sum + scores[i][j];
			sum += scores[i][j];
			//cout << scores[i][j] << " ";
		}
		cout << names[i] << "的总分为：" << sum << endl;
	}

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    六、函数

    6.1. 概述

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

    6.2. 函数的定义

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

    1. 返回值类型
    2. 函数名
    3. 参数表列
    4. 函数体语句
    5. return表达式
      在这里插入图片描述
      在这里插入图片描述
    #include
using namespace std;

//函数的定义
//语法：
//返回值类型  函数名  (参数列表)  { 函数体语句  return表达式 }

//加法函数，实现两个整型相加，并且将相加的结果进行返回
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    ·

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

    6.3 函数的调用

    功能：使用定义好的函数
    语法：函数名（参数）
    编程示例为：

    #include
using namespace std;

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

int main() {

	//main函数中调用add函数
	int a = 10;
	int b = 20;

	//函数调用语法：函数名称(参数)
	//a和b称为 实际参数， 简称实参
	//当调用函数的时候，实参的值会传递给形参
	int c = add(a, b);
	cout << "c = " << c << endl;

	a = 100;
	b = 500;
	c = add(a, b);
	cout << "c = " << c << endl;

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    6.4 值传递

    • 所谓值传递，就是函数调用时实参将数值传入给形参
    • 值传递时，如果形参发生，并不影响实参
      在这里插入图片描述
    a和b的值没有发生改变

    在这里插入图片描述

    #include
using namespace std;

//值传递
//定义函数，实现两个数字进行交换函数

//如果函数不需要返回值，声明的时候可以写void

void swap(int num1, int num2)
{
	cout << "交换前：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换后：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	//return;  返回值不需要的时候，可以不写return
}

int main() {

	int a = 10;
	int b = 20;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	//当我们做值传递的时候，函数的形参发生改变，并不影响实参
	swap(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    6.5 函数的常见样式

    常见的函数样式有4种：

    1. 无参无返
    2. 有参无返
    3. 无参有返
    4. 有参有返
    #include
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 1000;
}
//4. 有参有返
int test04(int a)
{
	cout << " this is test03 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;

	system("pause");
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    6.6 函数的声明

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

    • 函数的声明可以多次，但是函数的定义只有一次
    #include
using namespace std;

//函数的声明
//比较函数，实现两个整型数字进行比较，返回较大的值

//提前告诉编译器函数的存在，可以利用函数的声明
//函数的声明
//声明可以写多次，但是定义只能有一次
int max(int a, int b);

int main() {

	int a = 10;
	int b = 20;
	cout << max(a, b) << endl;

	system("pause");
	return 0;
}
//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    函数的声明可以让main函数调用的函数写在main函数后面，写声明可以让main函数知道有这个调用函数，让程序正常运行。

    6.7 函数的分文件编写

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

    函数分文件编写一般有4个步骤：

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

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    #include
using namespace std;
#include "swap.h"

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

函数的声明
//void swap(int a, int b);
函数的定义
//void swap(int a, int b)
//{
//	int 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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    总结

    csdn写作小技巧：
    一维数组名称的用途：

    二维数组定义的四种方式:
  • 相关阅读:
    flex布局与几个实例（含源码）
    【云原生之Docker实战】使用Docker部署Komga个人漫画服务器
    【shell】linux通过complete命令完成使用tab键自动补全
    C++ 递归与面向对象编程基础
    基于51单片机音乐盒LCD1602显示( proteus仿真+程序+原理图+设计报告+讲解视频）
    SpringMVC之注解RequestMapping
    双十二电容笔哪个品牌好？十大电容笔知名品牌
    解读Go分布式链路追踪实现原理
    【IC卡】终极版复卡器操作方法 ID卡读取方法
    iperf/iperf3 测试网络性能
  • 原文地址：https://blog.csdn.net/mw_1422102031/article/details/126274884