1 c++编程基础

重新系统学习c++语言，并将学习过程中的知识在这里抄录、总结、沉淀。同时希望对刷到的朋友有所帮助，一起加油哦！

生命就像一朵花，要拼尽全力绽放！死磕自个儿，身心愉悦！

1 c++揭开面纱

1.1 编程工具

注：开发环境指在windows机器。

实际项目开发中开发工具可选择：

(1) Visual Studio--可直接创建项目，并编译运行，较方便简单。

(2) vscode--可写代码，但对于Windows系统而言就需要安装Mingw-w64来获得编译器。（网上可搜索到安装配置方法不再累述）

(3) https://lightly.teamcode.com/ 初学者推荐这个站点，可以在线建项目，并运行出结果。方便快捷。

提示：本文采用 lightly 站点编程。

1.2 第一个c++小程序

#include<iostream>
using namespace std;

int main() {

	cout << "Hello world" << endl;


	return 0;
}

运行后输出：

1.3 注释

作用：在代码中加一些说明和解释，方便自己或其他程序员程序员阅读代码。

格式：

1. 单行注释：

通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明。

语法： // 注释信息

2. 多行注释：

通常放在一段代码的上方，对该段代码做整体说明。

语法： /* 注释信息 */

提示：编译器在编译代码时，会忽略注释的内容

#include<iostream>
using namespace std;

int main() {

	// 这是单行注释

    /*
    这是多行注释
    这是多行注释
    */
	
	system("pause");

	return 0;
}

1.4 变量

作用：给一段指定的内存空间起名，方便操作这段内存

语法：数据类型变量名 = 初始值;

示例：int a = 1;

注意：C++在创建变量时，必须给变量一个初始值，否则会报错

1.5 常量

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

定义常量两种方式：

1. #define 宏常量：

通常在文件上方定义，表示一个常量

语法：#define 常量名常量值

2. const修饰的变量

通常在变量定义前加关键字const，修饰该变量为常量，不可修改

语法：const 数据类型常量名 = 常量值

示例：

#include<iostream>
using namespace std;

//1、宏常量
#define day 7

int main() {

	cout << "一周里总共有 " << day << " 天" << endl;
	//day = 8;  //报错，宏常量不可以修改

	//2、const修饰变量
	const int month = 12;
	cout << "一年里总共有 " << month << " 个月份" << endl;
	//month = 24; //报错，常量是不可以修改的
	
	
	system("pause");

	return 0;
}

运行后输出：

1.6 关键字

作用：关键字是C++中预先保留的单词（标识符）

在定义变量或者常量时候，不要用关键字

C++关键字如下：

asm	else	new	this
auto	enum	operator	throw
bool	explicit	private	true
break	export	protected	try
case	extern	public	typedef
catch	false	register	typeid
char	float	reinterpret_cast	typename
class	for	return	union
const	friend	short	unsigned
const_cast	goto	signed	using
continue	if	sizeof	virtual
default	inline	static	void
delete	int	static_cast	volatile
do	long	struct	wchar_t
double	mutable	switch	while
dynamic_cast	namespace	template

完整关键字介绍可查阅：

C++ 的关键字（保留字）完整介绍 | 菜鸟教程

提示：在给变量或者常量起名称时候，不要用C++得关键字，否则会产生歧义。

1.7 标识符命名规则

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

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

建议：给标识符命名时，争取做到见名知意的效果，方便自己和他人的阅读。

2 数据类型

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

2.1 总括

基本的内置类型

C++ 为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型。下表列出了七种基本的 C++ 数据类型：

类型	关键字	备注
整型	int
浮点型	float
双浮点型	double
布尔型	bool	有两个值： true 真，本质是1 false 假，本质是0
字符型	char	定义： char ch = 'a'; 只能用单引号，且里面只能有一个字符，不能多个。字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元。要记住两个字符的ASCII编码：a--97,A--65,其他顺序推算。
无类型	void
宽字符型	wchar_t	真实定义： typedef short int wchar_t; 所以wchar_t 实际上的空间是和 short int 一样

一些基本类型可以使用一个或多个类型修饰符进行修饰：

signed
unsigned
short
long

下表显示了各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。

注意：不同系统会有所差异，一字节为 8 位。

注意：默认情况下，int、short、long都是带符号的，即 signed。

注意：long int 8 个字节，int 都是 4 个字节，早期的 C 编译器定义了 long int 占用 4 个字节，int 占用 2 个字节，新版的 C/C++ 标准兼容了早期的这一设定。

类型	位	范围
char	1 个字节	-128 到 127 或者 0 到 255
unsigned char	1 个字节	0 到 255
signed char	1 个字节	-128 到 127
int	4 个字节	-2147483648 到 2147483647
unsigned int	4 个字节	0 到 4294967295
signed int	4 个字节	-2147483648 到 2147483647
short int	2 个字节	-32768 到 32767
unsigned short int	2 个字节	0 到 65,535
signed short int	2 个字节	-32768 到 32767
long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int	8 个字节	0 到 18,446,744,073,709,551,615
float	4 个字节	精度型占4个字节（32位）内存空间，+/- 3.4e +/- 38 (~7 个数字)
double	8 个字节	双精度型占8 个字节（64位）内存空间，+/- 1.7e +/- 308 (~15 个数字)
long double	16 个字节	长双精度型 16 个字节（128位）内存空间，可提供18-19位有效数字。
wchar_t	2 或 4 个字节	1 个宽字符

2.2 sizeof

各数据类型所占内存空间不同，可能我们没那么好记忆来记住它们，c++提供了sizeof关键字来解决这个问题。

作用：利用sizeof关键字可以统计数据类型所占内存大小占用几个字节

语法： sizeof( 数据类型或变量)

示例：

#include <iostream>
using namespace std;

int main() {
    int a = 1;
    
    cout << "short 类型所占内存空间为： " << sizeof(short) << endl;

    cout << "int 类型所占内存空间为： " << sizeof(int) << endl;

    cout << "用变量a获取 int 类型所占内存空间为： " << sizeof(a) << endl;

    cout << "long 类型所占内存空间为： " << sizeof(long) << endl;

    cout << "long long 类型所占内存空间为： " << sizeof(long long) << endl;

    system("pause");

    return 0;
}

运行后输出：

编辑

2.3 字符串

作用：用于表示一串字符

两种风格：

1. C风格字符串：

char 变量名[] = "字符串值"

注意：C风格的字符串要用双引号括起来

2. C++风格字符串：

string 变量名 = "字符串值"

注意：C++风格字符串，需要加入头文件 #include <string>

示例：

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

int main() {
    char str1[] = "abc";
    cout << "str1字符串为：" << str1 << endl;

    string str2 = "123";
    cout << "str2字符串为：" << str2 << endl;

    return 0;
}

运行后输出：

编辑

2.4 数据的输入

作用：用于从键盘获取数据

关键字：cin

语法： cin >> 变量

示例：

#include <iostream>
using namespace std;

int main() {
    int a = 0;
    cout << "请给a赋值：" << endl;
    cin >> a;
    cout << "a的值为：" << a << endl;

    return 0;
}

运行后输出：

编辑

3 运算符

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

本章主要讲解以下几类运算符：

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

3.1 算术运算符

作用：用于处理四则运算

算术运算符包括以下符号：

运算符	术语	示例	结果
+	正号	+3	3
-	负号	-3	-3
+	加	10 + 5	15
-	减	10 - 5	5
*	乘	10 * 5	50
/	除	10 / 5	2
%	取模(取余)	10 % 3	1
++	前置递增	a=2; b=++a;	a=3; b=3;
++	后置递增	a=2; b=a++;	a=3; b=2;
--	前置递减	a=2; b=--a;	a=1; b=1;
--	后置递减	a=2; b=a--;	a=1; b=2;

注意：

在除法运算中，除数不能为0
在取模运算中，除数不能为0。只有整型变量可以进行取模运算，不能是浮点型变量。
整数进行除法运算，若除不尽，则结果只有整数部分，小数部分不保留。

3.2 赋值运算符

作用：用于将表达式赋值给变量

赋值运算符包括以下符号：

运算符	术语	示例	结果
=	赋值	a=1;b=a;	a=1;b=1;
+=	加等于	a=1;a+=2;	a=3;
-=	减等于	a=1;a-=2;	a=-1;
*=	乘等于	a=2;a*=3;	a=6;
/=	除等于	a=6;a/=2;	a=3;
%=	模等于	a=6;a%=4;	a=2;

3.3 比较运算符

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

比较运算符包括以下符号：

运算符	术语	示例	结果 (1为真，0为假)
==	等于	1==2	0
!=	不等于	1!=2	1
<	小于	1<2	1
>	大于	1>2	0
<=	小于等于	1<=2	1
>=	大于等于	1>=2	0

3.4 逻辑运算符

作用：用于表达式间的比较逻辑运算，并返回一个真值或假值

逻辑运算符包括以下符号：

运算符	术语	示例	结果 (1为真，0为假)
!	非	!a	若a为真，则结果为假；若a为假，则结果为真；
&&	与	a && b	若a和b都为真，则结果为真，否则结果为假
\|\|	或	a \|\| b	若a和b有一个为真，则结果为真；只有二者都为假时，结果为假

运算符

术语

示例

结果

(1为真，0为假)

非

若a为真，则结果为假；若a为假，则结果为真；

与

a && b

若a和b都为真，则结果为真，否则结果为假

或

a || b

若a和b有一个为真，则结果为真；只有二者都为假时，结果为假

总结规律：

非：真变假，假变真；

与：全真为真，其余为假；

或：全假为假，其余为真。

3.5 逗号运算符

作用：用于表达式的分隔。如果一个语句用多个分隔符分开多个表达式，通常返回最后一个表达式的值。

示例：

#include <iostream>
using namespace std;

int main() {
    int n = ( 3,4,5);
    cout << "n=" << n << endl;

    return 0;
}

输出结果：

n=5

3.6 条件运算符

三目运算符，又称三元运算符，或条件运算符。

格式：表达式1?表达式2:表达式3；

作用：根据表达式1的真假，返回结果。若表达式1为真，则返回表达式2的结果；若表达式1为假，则返回表达式3的结果。

示例：

#include <iostream>
using namespace std;

int main() {
    int a,b,c;
    a=7;
    b=6;
    //若a>b为真，c=a;若a>b为假，c=b;
    c=(a>b)?a:b;
    cout << "c=" << c << endl;

    return 0;
}

结果：

c=7

3.8 运算符优先级

作用：当多种运算符出现时，按怎样的运算次序。

（以下内容抄录自其他c++学习文档）

C语言运算符优先级

优先级	运算符	名称或含义	使用形式	结合方向	说明
1	[]	数组下标	数组名[常量表达式]	左到右	--
	()	圆括号	(表达式）/函数名(形参表)		--
	.	成员选择（对象）	对象.成员名		--
	->	成员选择（指针）	对象指针->成员名		--

2	-	负号运算符	-表达式	右到左	单目运算符
	~	按位取反运算符	~表达式
	++	自增运算符	++变量名/变量名++
	--	自减运算符	--变量名/变量名--
	*	取值运算符	*指针变量
	&	取地址运算符	&变量名
	!	逻辑非运算符	!表达式
	(类型)	强制类型转换	(数据类型)表达式		--
	sizeof	长度运算符	sizeof(表达式)		--

3	/	除	表达式/表达式	左到右	双目运算符
	*	乘	表达式*表达式
	%	余数（取模）	整型表达式%整型表达式
4	+	加	表达式+表达式	左到右	双目运算符
4	-	减	表达式-表达式	左到右	双目运算符
5	<<	左移	变量<<表达式	左到右	双目运算符
5	>>	右移	变量>>表达式	左到右	双目运算符

6	>	大于	表达式>表达式	左到右	双目运算符
	>=	大于等于	表达式>=表达式
	<	小于	表达式<表达式
	<=	小于等于	表达式<=表达式
7	==	等于	表达式==表达式	左到右	双目运算符
7	！=	不等于	表达式!= 表达式	左到右	双目运算符

8	&	按位与	表达式&表达式	左到右	双目运算符
9	^	按位异或	表达式^表达式	左到右	双目运算符
10	\|	按位或	表达式\|表达式	左到右	双目运算符
11	&&	逻辑与	表达式&&表达式	左到右	双目运算符
12	\|\|	逻辑或	表达式\|\|表达式	左到右	双目运算符

13	?:	条件运算符	表达式1? 表达式2: 表达式3	右到左	三目运算符

14	=	赋值运算符	变量=表达式	右到左	--
	/=	除后赋值	变量/=表达式		--
	*=	乘后赋值	变量*=表达式		--
	%=	取模后赋值	变量%=表达式		--
	+=	加后赋值	变量+=表达式		--
	-=	减后赋值	变量-=表达式		--
	<<=	左移后赋值	变量<<=表达式		--
	>>=	右移后赋值	变量>>=表达式		--
	&=	按位与后赋值	变量&=表达式		--
	^=	按位异或后赋值	变量^=表达式		--
	\|=	按位或后赋值	变量\|=表达式		--

15	，	逗号运算符	表达式,表达式,…	左到右	--

说明：

同一优先级的运算符，运算次序由结合方向所决定。
简单记就是：！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符

4 语句与程序流结构

C/C++支持最基本的三种程序运行结构：

顺序结构：程序按代码顺序执行
选择结构：依据条件是否满足，有选择的执行相应代码块
循环结构：依据条件是否满足，多次循环执行某段代码

4.1 语句分类

编辑

4.2 选择结构

4.2.1 if语句

(1)单行if语句

格式：

if(条件1)

{

条件1为真时，要执行的代码

}

#include <iostream>
using namespace std;

int main() {
    int score=0;
    cout << "请输入你的分数：";
    cin>> score;
    
    if(score>600)
    {
        cout << "恭喜你考上一本" << endl;
    }
   
    return 0;
}

输出：

a大于b

(2)多行if语句

格式：

if(条件1)

{

条件1为真时，要执行的代码

}

else{

条件1为假时，要执行的代码

}

示例：

#include <iostream>
using namespace std;

int main() {
    int score=0;
    cout << "请输入你的分数：";
    cin>> score;
    
    if(score>600)
    {
        cout << "恭喜你考上一本" << endl;
    }
    else{
        cout << "未考上一本" << endl;
    }

    return 0;
}

(3)多条件if语句

格式：

if(条件1)

{

条件1为真时，要执行的代码

}

else if(条件2){

条件2为真时，要执行的代码

}

……

else ｛

所有条件都不满足时，要执行的代码

｝

示例：

#include <iostream>
using namespace std;

int main() {
    int score=0;
    cout << "请输入你的分数：";
    cin>> score;
    
    if(score>600)
    {
        cout << "恭喜你考上一本" << endl;
    }
    else if(score>500){
        cout << "恭喜你考上二本" << endl;
    }
    else if(score>400){
        cout << "恭喜你考上三本" << endl;
    }
    else {
        cout << "未考上本科" << endl;
    }

    return 0;
}

4.2.2 switch语句

作用：根据表达式结果，执行多种选择条件的结果。

格式：

switch(表达式)

{

case 结果1: 执行语句;break;

case 结果2: 执行语句;break;

……

default: 执行语句;break;

}

示例：

#include <iostream>
using namespace std;

int main() {

	//请给电影评分 
	//10 ~ 9   经典   
	// 8 ~ 7   非常好
	// 6 ~ 5   一般
	// 5分以下 烂片

	int score = 0;
	cout << "请给电影打分" << endl;
	cin >> score;

	switch (score)
	{
	case 10:
	case 9:
		cout << "经典" << endl;
		break;
	case 8:
		cout << "非常好" << endl;
		break;
	case 7:
	case 6:
		cout << "一般" << endl;
		break;
	default:
		cout << "烂片" << endl;
		break;
	}

	system("pause");

	return 0;
}

注意：

1、switch的判断表达式类型只能是整型或字符类。不可以是一个区间。

2、case里如果没有break会一直往下执行后面的语句。

总结：

与if语句相比，对于多条件判断时，switch的优点是结构清晰，执行效率高；缺点是不可以判断区间。

4.3 循环结构

循环结构，指的是在满足条件下，重复执行某段代码语句。

4.3.1 while语句

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

格式：

while(循环条件){

循环语句

}

示例：

#include <iostream>
using namespace std;

int main() {
    //案例：输出1到9个数字
	int a = 1;
    while(a < 10){
        cout << a << endl;
        a++;
    }

	system("pause");

	return 0;
}

注意：

程序必须有不满足循环条件的时候，以便跳出循环，防止出现死循环的情况。

4.3.2 do while语句

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

格式：

do{
循环语句

}while(循环条件)

示例：

#include <iostream>
using namespace std;

int main() {
    //案例：输出1到9个数字
	int a = 1;
    do{
        cout << a << endl;
        a++;
    } while(a < 10)

	system("pause");

	return 0;
}

总结：

do while与while的区别在于，do while一定会执行一遍循环语句，再判断是否满足循环条件。

4.3.3 for语句

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

格式：

for(起始循环条件；条件表达式；末尾循环体)

{
循环语句

}

示例：

#include <iostream>
using namespace std;

int main() {
    // 打印 0到9的数字
    for(int a = 0; a < 10; a++)
    {
        cout << a << endl;
    }
	system("pause");

	return 0;
}

4.4 跳转语句

4.4.1 break

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

使用时机：

出现在switch条件语句中，用于终止case并跳出switch;
出现在循环结构中，用于跳出当前循环结构；
出现在嵌套循环结构中，跳出最近的内层循环。

4.4.2 continue

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

示例：

#include <iostream>
using namespace std;

int main() {
    // 打印 0到10以内的奇数
    for(int a = 0; a <= 10; a++)
    {
        if(a % 2 == 0 )
        {
            continue;
        }
        cout << a << endl;
    }
	system("pause");

	return 0;
}

输出：

4.4.3 goto

作用：无条件跳转到目的语句。

通常是打一个标记，然后执行goto语句，跳转到标记的位置。

示例：

#include <iostream>
using namespace std;

int main() {
    cout << "1" << endl;
    cout << "2" << endl;
    
    goto FLAG; // 跳转到FLAG标记处

    cout << "3" << endl;

    FLAG: //标记

    cout << "4" << endl;
	system("pause");

	return 0;
}

结果：

注意：

goto比较影响程序的可读性，不推荐使用。

5 数组

由相同的数据组成的一个集合，叫数组。

特点：

数组中的每个元素都是相同的数据类型；
数组中数据在内存中是连续存储的；

5.1 一维数组

5.1.1定义

有三种定义方式及特点：

(1) 数据类型数组名[ 数组长度 ];

数组长度固定
需要给元素赋值，若未赋值，则元素值不一定为0，可能是个不确定值，使用时需要注意，防止错误。

(2) 数据类型数组名[ 数组长度 ] = { 值1，值2 ...};

数组长度固定
元素值{}中已给定，若缺少，则用0补全；

(3) 数据类型数组名[ ] = { 值1，值2 ...};

数组长度根据{}中元素个数来确定，是个固定长度；
元素值{}中已给定；

#include <iostream>
using namespace std;

int main() {
    //定义方式1：数据类型 数组名[元素个数]
    // 若未给元素赋值，则元素的值是个不确定数。
    int arr1[10];
    arr1[0] = 10;
    arr1[1] = 20;
    
    cout << "打印arr1" << endl;
    for (int i = 0; i <= 9; i++) {
        cout << arr1[i] << endl;
    }

    //  定义方式2：数据类型 数组名[元素个数] = {值1，值2，……}
    // 如果{}中元素个数不足10个，则剩余元素值用0补全
    cout << "打印arr2" << endl;
    int arr2[10] = {1, 2, 3, 4, 5};
    for (int i = 0; i <= 19; i++) {
        cout << arr2[i] << endl;
    }

    //  定义方式2：数据类型 数组名[元素个数] = {值1，值2，……}
    cout << "打印arr3" << endl;
    int arr3[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
    for (int i = 0; i <= 9; i++) {
        cout << arr3[i] << endl;
    }


    //使用超出数组下标元素时，不会报错，但是值有问题
    for (int i = 20; i <= 30; i++) {
           cout<<"超出数组下标的错误元素值"<<arr3[i]<<endl;

    }
    system("pause");

    return 0;
}

结果：

打印arr1
10
20
0
0
4199536
0
4198688
0
816941264
32767
打印arr2
1
2
3
4
5
0
0
0
0
0
4199605
10
10
20
0
0
4199536
0
4198688
0
打印arr3
10
20
30
40
50
60
70
80
90
100
超出数组下标的错误元素值0
超出数组下标的错误元素值0
超出数组下标的错误元素值4199605
超出数组下标的错误元素值10
超出数组下标的错误元素值10
超出数组下标的错误元素值20
超出数组下标的错误元素值0
超出数组下标的错误元素值0
超出数组下标的错误元素值4199536
超出数组下标的错误元素值0
超出数组下标的错误元素值4198688

总结：

定义数组名不要和其他变量重名；
数组下标是从0开始的；
注意不要使用未赋值元素，可能是不确定的值。

5.1.2 数组名

用途：

1. 可以通过数组名统计整个数组占用内存大小； sizeof(数组名)

2. 可以通过数组名查看数组首地址； sizeof(数组名[0]) 或sizeof(数组名)

示例：

#include <iostream>
#include <stdio.h>
#include <string.h>
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. 可以通过数组名查看数组首地址；
    printf("数组首地址为：%d\n",arr);
    printf("第一个元素首地址为：%d\n",&arr[0]);
    printf("第二个元素首地址为：%d\n",&arr[1]);
    system("pause");

    return 0;
}

结果：

整个数组占用内存空间为：40
每个元素占用内存空间为：4
数组元素个数为：10
数组首地址为：922989696
第一个元素首地址为：922989696
第二个元素首地址为：922989700

总结：

数组名是常量不可以赋值；
直接打印数组名，可以查看数组的首地址；
sizeof(数组名)可获取数组所占内存大小；

5.1.3 元素逆置

需求：声明一个6个元素的数组，并且将元素逆置.

(如原数组元素为：1,3,2,5,4,6;逆置后输出结果为:6,4,5,2,3,1);
代码：

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

int main() {
    //  1、创建数组
    int arr[6] = {1, 3, 2, 5, 4, 6};
    for (int i = 0; i < 6; i++) {
        cout << arr[i] << endl;
    }

    //  2、实现逆置
    //  2.1 记录起始下标
    //  2.2 记录结束下标
    //  2.3 互换起始下标和结束下标元素
    //  2.4 起始下标++  结束下标--
    //  2.5 循环执行2.1至2.4步骤，直至起始下标 >= 结束下标
    int start = 0;                              //起始坐标
    int end = sizeof(arr) / sizeof(arr[0]) - 1; //结束坐标
    while (start < end) {
        //实现元素互换
        int tmp = arr[start];
        arr[start] = arr[end];
        arr[end] = tmp;

        // 下标更新
        start++;
        end--;
    }

    //  3、打印逆置后的数组
    cout << "逆置后的数组：" << endl;
    for (int i = 0; i < 6; i++) {
        cout << arr[i] << endl;
    }

    system("pause");

    return 0;
}

5.1.4 冒泡排序

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

int main() {
    // 冒泡排序 将数组按升序排序
    // 1 比较相邻的元素，如果第一个比第二个大，就交换；
    // 2 对每一个相邻的元素做同样的操作，执行完毕后，找到最大值；
    // 3 重复以上两个步骤，每次比较次数减1，直到不需要比较
    // 思考方法：可通过画图找到排序轮次，每轮比对次数的规律。
    // 排序总轮数 = 元素个数 -1
    // 每轮比对次数 = 元素个数 - 排序轮数 - 1

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

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

    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }

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

    system("pause");
    return 0;
}

5.2 二维数组

二维数组相对一维数组，多一个纬度。

5.2.1定义

有四种定义方法：

1 数据类型数组名[行数][列数];

2 数据类型数组名[行数][列数] = {{数据1，数据2}, {数据3，数据4}};

3 数据类型数组名[行数][列数] = {数据1，数据2，数据3，数据4};

特点：根据行数及列数推导出每个元素的位置。

4 数据类型数组名[][列数] = {数据1，数据2数据3，数据4};

特点：根据{}中元素个数及列数可推导出行数，及每个元素的位置。

总结：

推荐使用定义2，清晰明了。

定义二维数组要给定行数列数，在定义时初始化了数据的情况下可以省略行数

示例：

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

int main() {

    //     1 数据类型 数组名[行数][列数]; 
    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;
    cout << "arr1:" << endl;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            cout << arr1[i][j];
        }
        cout << endl;
    }

    //     2 数据类型 数组名[行数][列数] = {{数据1，数据2}, {数据3，数据4}};
    int arr2[2][3] = {{1, 2, 3}, {4, 5, 6}};
    cout << "arr2:" << 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 << "arr3:" << 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}; // 若初始化成{{1, 2, 3}, {4, 5, 6}};也可以
    cout << "arr4:" << endl;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            cout << arr4[i][j];
        }
        cout << endl;
    }

    system("pause");
    return 0;
}

5.2.2 数组名

用途：

查看占用内存空间大小
查看二维数组的首地址

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

int main() {
    // 查看占用内存空间大小
    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;

    // 查看二维数组的首地址
    printf("二维数组的首地址：%d\n", arr);
    printf("二维数组第一行数据首地址：%d\n", arr[0]);
    printf("二维数组第二行数据首地址：%d\n", arr[1]);

    printf("二维数组第一个元素首地址：%d\n", &arr[0][0]);
    printf("二维数组第二个元素首地址：%d\n", &arr[0][1]);

    system("pause");
    return 0;
}

注意：

查看具体元素的地址，需要在元素前加&。例如： &arr[0][0]

6 函数

6.1 概述

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

6.2 函数的定义

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

语法

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

函数体语句

return表达式

}

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

示例：

//函数定义
int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}

6.3 函数的调用

用途：使用定义好的函数

语法：函数名（参数）

示例：

#include <iostream>
#include <stdio.h>

using namespace std;

//函数定义
int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
{
    int sum = num1 + num2;
    return sum;
}


int main() {
    int a = 10;
    int b = 10;
    //调用add函数
    int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
    cout << "sum = " << sum << endl;

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

    system("pause");
    return 0;

}

总结：函数定义里小括号内称为形参，函数调用时传入的参数称为实参

6.4 值传递

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

值传递时，如果形参发生，并不会影响实参

示例：

#include <iostream>
#include <stdio.h>

using namespace std;

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;
    swap(a, b);

    cout << "mian中的 a = " << a << endl;
    cout << "mian中的 b = " << b << endl;

    system("pause");

    return 0;

}

总结：值传递时，形参是修饰不了实参的

6.5 函数的常见样式

常见的函数样式有4种：

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

示例：

//函数常见样式
//1、 无参无返
void test01()
{
    //void a = 10; //无类型不可以创建变量,原因无法分配内存
    cout << "this is test01" << endl;
    //test01(); 函数调用
}

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

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

//4、有参有返
int test04(int a, int b)
{
    cout << "this is test04 " << endl;
    int sum = a + b;
    return sum;
}

6.6 函数的声明

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

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

示例：

#include <iostream>
#include <stdio.h>

using namespace std;

//声明可以多次，定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);

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

int main() {
    int a = 100;
    int b = 200;
    cout << max(a, b) << endl;

    system("pause");
    return 0;
}

6.7 函数的分文件编写

作用：将函数声明和函数定义主体分开成两个文件保存，让代码结构更加清晰

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

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

示例：

三个文件的代码分别如下：


//swap.h文件
#include<iostream>
using namespace std;

//实现两个数字交换的函数声明
void swap(int a, int b);


//swap.cpp文件
#include "swap.h"

void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

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



//main函数文件
#include "swap.h"
int main() {
	int a = 100;
	int b = 200;
	swap(a, b);

	system("pause");
	return 0;
}

总结：

在调用函数的文件中，需要引用函数头文件： #include "函数文件名.h"

7 指针

7.1 指针基本概念

作用：通过指针来访问内存空间。

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

7.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;

	// 2 指针使用
	*p = 2000;
	cout << "a = " << a << endl;
	cout << "*p = " << *p << endl;

    system("pause");
	return 0;
}

7.3 指针的内存空间

所有数据类型指针：

在32位操作系统下，指针占用4字节内存空间（x86）
在64位操作系统下，指针占用8字节内存空间（x64）

示例：

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int* p = &a;
	cout << "int*占用内存大小：" << sizeof(p) << endl;
	cout << "long*占用内存大小：" << sizeof(long *) << endl;
	cout << "char *占用内存大小：" << sizeof(char *) << endl;
	cout << "double *占用内存大小：" << sizeof(double*) << endl;

	system("pause");
	return 0;
}

7.4 空指针和野指针

1 空指针

空指针定义：指针变量指向内存编号为0的空间；

用途：一般在初始化指针变量时，先定义指针为空指针。

语法：数据类型 * 指针名 = NULL；

例：int * p = NULL;

注意：空指针指向的内存是不可以访问的。换句话说在空指针未重新指向其他内存空间时不可以使用。内存编号为0至255的空间为系统占用内存，都不运行用户访问使用。

示例：

#include <iostream>
using namespace std;

int main()
{
	// 指针变量p指向内存地址编号0的空间
	int* p = NULL;

	// 访问空指针会报错
	// 内存编号0至255为系统占用编号的空间，不运行用户访问
	//cout << *p << endl;

	//可将指针重新指向其他内存空间再访问
	int a = 10;
	p = &a;
	cout << *p<< endl;

	system("pause");
	return 0;
}

2 野指针

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

#include <iostream>
using namespace std;

int main()
{
	// 野指针，指向的内存地址并不是自己申请过的，属于指向非法内存空间
	int* p = (int *)0x112;

	// 访问会报错
	cout << *p<< endl;

	system("pause");
	return 0;
}

7.5 const修饰指针

三种情况：

1、const修饰指针--常量指针

特点：指针指向可以修改，指针指向的值不可以修改

2、const修饰常量--指针常量

特点：指针指向不可以修改，指针指向的值可以修改

3、const既修饰指针，也修饰常量

特点：指针指向不可以修改，指针指向的值也不可以修改

看const右侧紧跟的是指针还是变量名，是指针就是常量指针，是变量名就是指针常量。

示例：

#include <iostream>
using namespace std;

int main()
{
	int a = 1;
	int b = 2;

	// 1 const修饰指针 常量指针
	const int* p = &a;
	// *p = 10; //err
	p = &b;

	// 2 const修饰常量 
	int* const p2 = &a;
	*p2 = 10;
	//p2 = &b;// err

	// 3 const修饰指针和常量
	const int* const p3 = &a;
	//*p3 = 20; // err
	//p3 = &b;// err

	system("pause");
	return 0;
}

7.6 指针和数组

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

示例：

#include <iostream>
using namespace std;

int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int* p = arr;// 指向数组的首地址

	cout << "第一个元素："<< * p << endl;
	cout <<"指针访问第一个元素："<< * p << endl;

	for (int i = 0; i < 5; i++)
	{
		//cout << arr[i];
		cout << *p << endl;
		p++;
	}

	system("pause");
	return 0;
}

7.7 指针和函数

作用：利用指针做函数参数，在函数内可以修改实参的值。

示例：

#include <iostream>
using namespace std;

void swap(int* p1, int* p2) {
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

int main()
{
	int a = 10;
	int b = 20;

	// 地址传递参数
	swap(&a, &b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

总结：如果不想改变实参值，就用值传递；想改变实参的值，就用地址传递。

7.8 指针、数组和函数

案例：封装一个函数，使用指针形参，利用冒泡排序，实现对整型数组的升序排序。

#include <iostream>
using namespace std;

void sort(int* arr, int len) {
	for (int i = 0; i < len-1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

void printArr(int* p, int len) {
	for (int i = 0; i < 10; i++) {
		cout << *p << endl;
		p++;
	}
}

int main()
{
	int arr[10] = { 2,4,6,8,0,1,3,5,7,9 };

	sort(arr, 10);
	printArr(arr, 10);

	system("pause");
	return 0;
}

9 结构体

9.1 结构体的基本概念

结构体属于用户自己定义的数据类型，运行用户存储不同的成员元素数据类型。

9.2 结构体定义和使用

语法：

struct 结构体名｛

结构体成员列表

｝;

结构体成员列表是一些数据类型变量定义。

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

struct 结构体名变量名；
struct 结构体名变量名 = ｛成员值1，成员值2……}
定义结构体时在{}后面顺便定义了变量名；

示例：

#include <iostream>
using namespace std;

struct Student {
	string name;
	int age;
	int score;
}s;  // 第3种定义方式

int main()
{
	// 第1种定义方式
	struct Student s1;
	s1.name = "andy";
	s1.age = 18;
	s1.score = 100;
	cout << "name:" << s1.name << " age:" << s1.age << " score:" << s1.score<<endl;

	// 第2种定义方式
	struct Student s2 = {"echo",19,99};
	cout << "name:" << s2.name << " age:" << s2.age << " score:" << s2.score << endl;

	// 第三种定义方式的赋值
	s.name = "helly";
	s.age = 20;
	s.score = 80;
	cout << "name:" << s.name << " age:" << s.age << " score:" << s.score << endl;

	s = { "test",30,70 };
	cout << "name:" << s.name << " age:" << s.age << " score:" << s.score << endl;

	system("pause");
	return 0;
}

9.3结构体数组

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

语法：struct 结构体名数组名[元素个数] = ｛｛结构体成员值1｝，｛结构体成员值2｝……｝

示例：

#include <iostream>
using namespace std;

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

int main()
{
	// 结构体数组
	struct Student s[3] = {
		{"echo",19,99} ,
		{"echo2",29,89} ,
		{"echo3",39,79}
	};

	s[2].name = "helly";
	s[2].age = 20;
	s[2].score = 80;
	for (int i = 0; i < 3; i++) {
		cout << " name:" << s[i].name
			<< " age:" << s[i].age
			<< " score:" << s[i].score
			<< endl;
	}

	system("pause");
	return 0;
}

9.4 结构体指针

作用：通过指针来访问结构体中的成员变量。

结构体指针利用 -> 来访问结构体成员变量。

示例：

#include <iostream>
using namespace std;

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

int main()
{
	// 结构体数组
	struct Student s = { "echo",19,99 };
	Student* p = &s;

	// 结构体指针用 -> 来访问结构体成员变量
	cout << " name:" << p->name
		<< " age:" << p->age
		<< " score:" << p->score
		<< endl;

	system("pause");
	return 0;
}

9.5 结构体嵌套结构体

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

示例：

#include <iostream>
#include<string>

using namespace std;

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

struct Teacher {
	int id;
	string name;
	Student s;
};

int main()
{
	Student s1 = { "echo",19,99 };
	Teacher t = { 1,"张三",s1 };

	// 结构体指针用 -> 来访问结构体成员变量
	cout << "老师的信息：id:" << t.id
		<< " name:" << t.name
		<< " 所带学生信息：name:" << t.s.name
		<< " age:" << t.s.age
		<< " score:" << t.s.score
		<< endl;

	system("pause");
	return 0;
}

9.6 结构体做函数参数

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

传递方式有两种：

值传递
地址传递

示例：

#include <iostream>
#include<string>

using namespace std;

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

// 打印
// 1 值传递 不会修改到结构体中实参的值
void printStudent1(Student s) {
	s.age = 100;
	cout << "printStudent1 name:" << s.name << " age:" << s.age << " score:" << s.score << endl;
}

// 打印
// 2 地址传递  会修改到结构体中实参的值
void printStudent2(Student* s) {
	s->age = 200;
	cout << "printStudent2 name:" << s->name << " age:" << s->age << " score:" << s->score << endl;
}

int main()
{
    Student s = { "echo",19,99 };

	printStudent1(s);
	cout << "main: name:" << s.name << " age:" << s.age << " score:" << s.score << endl;

	printStudent2(&s);
	cout << "main: name:" << s.name << " age:" << s.age << " score:" << s.score << endl;

	system("pause");
	return 0;
}

9.7 结构体中const

作用：用const防止修改的误操作。

示例：

#include <iostream>
#include<string>

using namespace std;

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

// 打印
// 形参用指针可以节省空间，而且不会复制新的副本
void printStudent2(const Student* s) {
	// s->age = 200;// 会直接报错
	cout << "printStudent2 name:" << s->name << " age:" << s->age << " score:" << s->score << endl;
}

int main()
{
    Student s = { "echo",19,99 };

	printStudent2(&s);
	cout << "main: name:" << s.name << " age:" << s.age << " score:" << s.score << endl;

	system("pause");
	return 0;
}

总结：指针前加了const修饰之后，就变成了只读变量不能在函数内部修改，防止误修改。

附

1 ASCII 编码一览表

SCII 编码一览表（十进制0-31、127为控制字符，其他为可显示字符）
二进制	十进制	十六进制	字符/缩写	解释
00000000	0	00	NUL (NULL)	空字符
00000001	1	01	SOH (Start Of Headling)	标题开始
00000010	2	02	STX (Start Of Text)	正文开始
00000011	3	03	ETX (End Of Text)	正文结束
00000100	4	04	EOT (End Of Transmission)	传输结束
00000101	5	05	ENQ (Enquiry)	请求
00000110	6	06	ACK (Acknowledge)	回应/响应/收到通知
00000111	7	07	BEL (Bell)	响铃
00001000	8	08	BS (Backspace)	退格
00001001	9	09	HT (Horizontal Tab)	水平制表符
00001010	10	0A	LF/NL(Line Feed/New Line)	换行键
00001011	11	0B	VT (Vertical Tab)	垂直制表符
00001100	12	0C	FF/NP (Form Feed/New Page)	换页键
00001101	13	0D	CR (Carriage Return)	回车键
00001110	14	0E	SO (Shift Out)	不用切换
00001111	15	0F	SI (Shift In)	启用切换
00010000	16	10	DLE (Data Link Escape)	数据链路转义
00010001	17	11	DC1/XON (Device Control 1/Transmission On)	设备控制1/传输开始
00010010	18	12	DC2 (Device Control 2)	设备控制2
00010011	19	13	DC3/XOFF (Device Control 3/Transmission Off)	设备控制3/传输中断
00010100	20	14	DC4 (Device Control 4)	设备控制4
00010101	21	15	NAK (Negative Acknowledge)	无响应/非正常响应/拒绝接收
00010110	22	16	SYN (Synchronous Idle)	同步空闲
00010111	23	17	ETB (End of Transmission Block)	传输块结束/块传输终止
00011000	24	18	CAN (Cancel)	取消
00011001	25	19	EM (End of Medium)	已到介质末端/介质存储已满/介质中断
00011010	26	1A	SUB (Substitute)	替补/替换
00011011	27	1B	ESC (Escape)	逃离/取消
00011100	28	1C	FS (File Separator)	文件分割符
00011101	29	1D	GS (Group Separator)	组分隔符/分组符
00011110	30	1E	RS (Record Separator)	记录分离符
00011111	31	1F	US (Unit Separator)	单元分隔符
00100000	32	20	(Space)	空格
00100001	33	21	!
00100010	34	22	"
00100011	35	23	#
00100100	36	24	$
00100101	37	25	%
00100110	38	26	&
00100111	39	27	'
00101000	40	28	(
00101001	41	29	)
00101010	42	2A	*
00101011	43	2B	+
00101100	44	2C	,
00101101	45	2D	-
00101110	46	2E	.
00101111	47	2F	/
00110000	48	30	0
00110001	49	31	1
00110010	50	32	2
00110011	51	33	3
00110100	52	34	4
00110101	53	35	5
00110110	54	36	6
00110111	55	37	7
00111000	56	38	8
00111001	57	39	9
00111010	58	3A	:
00111011	59	3B	;
00111100	60	3C	<
00111101	61	3D	=
00111110	62	3E	>
00111111	63	3F	?
01000000	64	40	@
01000001	65	41	A
01000010	66	42	B
01000011	67	43	C
01000100	68	44	D
01000101	69	45	E
01000110	70	46	F
01000111	71	47	G
01001000	72	48	H
01001001	73	49	I
01001010	74	4A	J
01001011	75	4B	K
01001100	76	4C	L
01001101	77	4D	M
01001110	78	4E	N
01001111	79	4F	O
01010000	80	50	P
01010001	81	51	Q
01010010	82	52	R
01010011	83	53	S
01010100	84	54	T
01010101	85	55	U
01010110	86	56	V
01010111	87	57	W
01011000	88	58	X
01011001	89	59	Y
01011010	90	5A	Z
01011011	91	5B	[
01011100	92	5C	\
01011101	93	5D	]
01011110	94	5E	^
01011111	95	5F	_
01100000	96	60	`
01100001	97	61	a
01100010	98	62	b
01100011	99	63	c
01100100	100	64	d
01100101	101	65	e
01100110	102	66	f
01100111	103	67	g
01101000	104	68	h
01101001	105	69	i
01101010	106	6A	j
01101011	107	6B	k
01101100	108	6C	l
01101101	109	6D	m
01101110	110	6E	n
01101111	111	6F	o
01110000	112	70	p
01110001	113	71	q
01110010	114	72	r
01110011	115	73	s
01110100	116	74	t
01110101	117	75	u
01110110	118	76	v
01110111	119	77	w
01111000	120	78	x
01111001	121	79	y
01111010	122	7A	z
01111011	123	7B	{
01111100	124	7C	\|
01111101	125	7D	}
01111110	126	7E	~
01111111	127	7F	DEL (Delete)	删除

posted on 2022-11-24 11:29 爱学习的小灵子阅读(132) 评论(0) 编辑收藏举报