前言

前几天有粉丝问我，大一结束c++刚学完，不知道自己目前学得怎么样？要掌握的知识点有没有都弄懂了？是否基础入门了？

这就安排上，熬夜爆肝整理出来的C++基础入门知识！

一篇文带你入门C++！一篇文带你疏通C++基础入门知识点！

目录

前言1 c++入门初识1.1 hello world1.2 注释1.3 变量1.4 常量1.5 关键字1.6 命名规则2 数据类型2.1 整型2.2 浮点型2.3 字符型2.4 字符串2.5 布尔类型2.6 转义字符3 运算符3.1 算数运算符3.2 关系运算符3.3 逻辑运算符3.4 位运算符3.5 赋值运算符4 程序流程结构4.1 判断类型4.2 循环类型4.3 循环控制语句5 数组5.1 数组定义创建5.2 数组指针6 函数6.1 函数的定义6.2 函数的调用6.3 函数的声明6.4 函数的参数7 指针7.1 指针变量的定义使用7.2 空指针和野指针7.3 const修饰指针7.4 指针、数组7.5 指针、函数7.6 指针、数组、函数

1 c++入门初识

C++ 是一种静态类型、编译式、通用、大小写敏感、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。

1.1 hello world

我们从最简单的hello world开始。下面就是一个最简单的C++程序。

// C++ 语言定义了很多头文件，包含程序中必需的或有用的内容 iostream就是#include <iostream>// 告诉编译器使用 std 命名空间。命名空间是 C++ 中一个新概念using namespace std;// main() 是主函数，程序从这里开始执行int main(){cout << "Hello World"; // 输出 Hello Worldreturn 0; // 终止 main( )函数，并向调用进程返回0}

1.2 注释

可以在代码片段中添加一些说明和解释，方便自己或别人阅读理解写的代码。

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

注释方式：

单行注释 ： // 注释内容

通常放在一行代码上方或者末尾多行注释： /* 注释内容 */

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

1.3 变量

可以对某段内存空间起名字，方便操作该内存空间。

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

#include<iostream>using namespace std;int main() {// 定义变量//数据类型 变量名 = 初始值int a = 12;cout << "a = " << a << endl;system("pause");return 0;}

1.4 常量

可以用来存储，无法修改的数据。

常量定义方式：

#define宏常量：#define 常量名 常量值const修饰的变量：const 数据类型 常量名 = 常量值

//1、宏常量#define day 7int main() {cout << "一周有 " << day << " 天" << endl;//day = 8; //error，宏常量不可修改//2、const修饰变量const int month = 12;cout << "一年有 " << month << " 个月份" << endl;//month = 24; //error，常量不可修改的system("pause");return 0;}

1.5 关键字

关键字是C++中预先保留的单词，又称为标识符。 这些关键词都是有特殊含义的，所以后面我们定义变量或者常量名称时，不能用这些关键字。

C++关键字：

1.6 命名规则

C++中给变量、常量命名时，为了阅读理解，起名字的时候最好做到见名知义。当然命名也有自己的规则：

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

2 数据类型

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

2.1 整型

整型变量表示的是整数数据，c++对于整数类型总共有4种，主要的差异是占内存空间不同。

2.2 浮点型

浮点型都是用来表示小数，分为2种。

单精度float和双精度double，他们的区别在于表示的有效数字范围不同。

int main() {float f1 = 3.14f;double d1 = 3.14;cout << f1 << endl;cout << d1<< endl;cout << "float sizeof = " << sizeof(f1) << endl;cout << "double sizeof = " << sizeof(d1) << endl;//科学计数法float f2 = 3e2; // 3 * 10 ^ 2 cout << "f2 = " << f2 << endl;float f3 = 3e-2; // 3 * 0.1 ^ 2cout << "f3 = " << f3 << endl;system("pause");return 0;}

2.3 字符型

字符型变量用于显示单个字符。例如 a， b， c这些英文字母。

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

2. 单引号内只能有一个字符，不能是字符串。

3. 字符型变量只占用1个字节

int main() {char ch = 'a';cout << ch << endl;cout << sizeof(char) << endl;//ch = "abcde"; //错误，不可以用双引号//ch = 'abcde'; //错误，单引号内只能引用一个字符cout << (int)ch << endl; //查看字符a对应的ASCII码ch = 97; //可以直接用ASCII给字符型变量赋值cout << ch << endl;system("pause");return 0;}

2.4 字符串

上面介绍了字符，而字符串就是用来表示一串字符的。

C++中字符串定义有2中方式：

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

int main() {string str = "hello world";cout << str << endl;char str1[] = "hello world";cout << str1 << endl;system("pause");return 0;

2.5 布尔类型

布尔类型用来判断数据值的真或假。bool类型占1个字节内存空间。

bool类型只有两个值：

true — 真 （本质是1）false — 假（本质是0）

int main() {bool flag = true;cout << flag << endl; // 1flag = false;cout << flag << endl; // 0cout << "size of bool = " << sizeof(bool) << endl; //1system("pause");return 0;}

2.6 转义字符

用于表示不能显示出来的ASCII字符。

3 运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号，执行代码的运算。

C++ 内置了丰富的运算符，提供了以下类型的运算符：

算术运算符关系运算符逻辑运算符位运算符赋值运算符

3.1 算数运算符

int main() {int a1 = 10;int b1 = 3;cout << a1 + b1 << endl;cout << a1 - b1 << endl;cout << a1 * b1 << endl;cout << a1 / b1 << endl; //两个整数相除结果依然是整数int a2 = 10;int b2 = 20;cout << a2 / b2 << endl; int a3 = 10;int b3 = 0;//cout << a3 / b3 << endl; //报错，除数不可以为0//两个小数可以相除double d1 = 0.5;double d2 = 0.25;cout << d1 / d2 << endl;int a3 = 10;int b3 = 0;//cout << a3 % b3 << endl; //取模运算时，除数也不能为0//两个小数不可以取模double d1 = 3.14;double d2 = 1.1;//cout << d1 % d2 << endl;//后置递增int a = 10;a++; //等价于a = a + 1cout << a << endl; // 11//前置递增int b = 10;++b;cout << b << endl; // 11//区别//前置递增先对变量进行++，再计算表达式int a2 = 10;int b2 = ++a2 * 10;cout << b2 << endl;//后置递增先计算表达式，后对变量进行++int a3 = 10;int b3 = a3++ * 10;cout << b3 << endl;system("pause");return 0;}

3.2 关系运算符

进行表达式比较，并返回一个布尔类型的返回值–真（1）或假（0）。

比较运算符有以下符号：

#include <iostream>using namespace std;int main(){int a = 21;int b = 10;int c ;if( a == b ){cout << "Line 1 - a 等于 b" << endl ;}else{cout << "Line 1 - a 不等于 b" << endl ;}if ( a < b ){cout << "Line 2 - a 小于 b" << endl ;}else{cout << "Line 2 - a 不小于 b" << endl ;}if ( a > b ){cout << "Line 3 - a 大于 b" << endl ;}else{cout << "Line 3 - a 不大于 b" << endl ;}/* 改变 a 和 b 的值 */a = 5;b = 20;if ( a <= b ){cout << "Line 4 - a 小于或等于 b" << endl ;}if ( b >= a ){cout << "Line 5 - b 大于或等于 a" << endl ;}return 0;}

输出结果：

Line 1 - a 不等于 bLine 2 - a 不小于 bLine 3 - a 大于 bLine 4 - a 小于或等于 bLine 5 - b 大于或等于 a

3.3 逻辑运算符

根据表达式的值返回真或假。

#include <iostream>using namespace std;int main(){int a = 5;int b = 20;int c ;if ( a && b ){cout << "Line 1 - 条件为真"<< endl ;}if ( a || b ){cout << "Line 2 - 条件为真"<< endl ;}/* 改变 a 和 b 的值 */a = 0;b = 10;if ( a && b ){cout << "Line 3 - 条件为真"<< endl ;}else{cout << "Line 4 - 条件不为真"<< endl ;}if ( !(a && b) ){cout << "Line 5 - 条件为真"<< endl ;}return 0;}

输出结果：

Line 1 - 条件为真Line 2 - 条件为真Line 4 - 条件不为真Line 5 - 条件为真

3.4 位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

假设如果 A = 60，B = 13，二进制格式表示如下所示：

A = 0011 1100

B = 0000 1101

#include <iostream>using namespace std;int main(){unsigned int a = 60;// 60 = 0011 1100 unsigned int b = 13;// 13 = 0000 1101int c = 0; c = a & b; // 12 = 0000 1100cout << "Line 1 - c 的值是 " << c << endl ;c = a | b; // 61 = 0011 1101cout << "Line 2 - c 的值是 " << c << endl ;c = a ^ b; // 49 = 0011 0001cout << "Line 3 - c 的值是 " << c << endl ;c = ~a;// -61 = 1100 0011cout << "Line 4 - c 的值是 " << c << endl ;// 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）c = a << 2; // 240 = 1111 0000cout << "Line 5 - c 的值是 " << c << endl ;// 二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。c = a >> 2; // 15 = 0000 1111cout << "Line 6 - c 的值是 " << c << endl ;return 0;}

3.5 赋值运算符

赋值运算符将表达式的值赋给变量，包括以下几个符号：

int main() {//赋值运算符// =int a = 10;a = 100;cout << "a = " << a << endl;// +=a = 10;a += 2; // a = a + 2;cout << "a = " << a << endl;// -=a = 10;a -= 2; // a = a - 2cout << "a = " << a << endl;// *=a = 10;a *= 2; // a = a * 2cout << "a = " << a << endl;// /=a = 10;a /= 2; // a = a / 2;cout << "a = " << a << endl;// %=a = 10;a %= 2; // a = a % 2;cout << "a = " << a << endl;system("pause");return 0;}

4 程序流程结构

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

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

4.1 判断类型

判断结构要求指定一个或多个要评估或测试的条件，以及条件为真时要执行的语句（必需的）和条件为假时要执行的语句（可选的）。

1. if else语句：

#include <iostream>using namespace std;int main (){// 局部变量声明int a = 100;int b = 200;// 检查布尔条件if( a == 100 ){// 如果条件为真，则检查下面的条件if( b == 200 ){// 如果条件为真，则输出下面的语句cout << "a 的值是 100，且 b 的值是 200" << endl;}}cout << "a 的准确值是 " << a << endl;cout << "b 的准确值是 " << b << endl;return 0;}

输出结果：

a 的值是 100，且 b 的值是 200a 的准确值是 100b 的准确值是 200

2. switch语句：

#include <iostream>using namespace std;int main (){// 局部变量声明int a = 100;int b = 200;switch(a) {case 100:cout << "这是外部 switch 的一部分" << endl;switch(b) {case 200:cout << "这是内部 switch 的一部分" << endl;}}cout << "a 的准确值是 " << a << endl;cout << "b 的准确值是 " << b << endl;return 0;}

输出结果：

这是外部 switch 的一部分这是内部 switch 的一部分a 的准确值是 100b 的准确值是 200

3. ? : 运算符

#include <iostream>using namespace std;int main (){// 局部变量声明int x, y = 10;x = (y < 10) ? 30 : 40;cout << "value of x: " << x << endl; return 0;}

输出结果：

value of x: 40

4.2 循环类型

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

int main() {int num = 0;do{cout << num << endl;num++;} while (num < 10);system("pause");return 0;}

do…while和while循环区别在于，do…while先执行一次循环语句，再判断循环条件。

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

执行过程：

4.3 循环控制语句

1. break：

#include <iostream>using namespace std;int main (){// 局部变量声明int a = 10;// do 循环执行do{cout << "a 的值：" << a << endl;a = a + 1;if( a > 15){// 终止循环break;}}while( a < 20 ); return 0;}

输出结果：

a 的值： 10a 的值： 11a 的值： 12a 的值： 13a 的值： 14a 的值： 15

2. continue：

#include <iostream>using namespace std;int main (){// 局部变量声明int a = 10;// do 循环执行do{if( a == 15){// 跳过迭代a = a + 1;continue;}cout << "a 的值：" << a << endl;a = a + 1;}while( a < 20 ); return 0;}

输出结果：

a 的值： 10a 的值： 11a 的值： 12a 的值： 13a 的值： 14a 的值： 16a 的值： 17a 的值： 18a 的值： 19

3. goto：

#include <iostream>using namespace std;int main (){// 局部变量声明int a = 10;// do 循环执行LOOP:do{if( a == 15){// 跳过迭代a = a + 1;goto LOOP;}cout << "a 的值：" << a << endl;a = a + 1;}while( a < 20 ); return 0;}

输出结果：

a 的值： 10a 的值： 11a 的值： 12a 的值： 13a 的值： 14a 的值： 16a 的值： 17a 的值： 18a 的值： 19

5 数组

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

数组中的每个数据元素都是相同的数据类型由连续的内存位置组成

5.1 数组定义创建

C++ 中可以逐个初始化数组，也可以使用一个初始化语句，如下所示：

// 一维数组//数据类型 数组名[元素个数];int score[10];//利用下标赋值score[0] = 100;score[1] = 99;score[2] = 85;//数据类型 数组名[元素个数] = {值1，值2 ，值3 ...};//如果{}内不足10个数据，剩余数据用0补全int score2[10] = {100, 90,80,70,60,50,40,30,20,10 };// 二维数组//数组类型 数组名 [行数][列数]int arr[2][2];arr[0][0] = 1;arr[0][1] = 2;arr[1][0] = 3;arr[1][1] = 4;//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };int arr2[2][3] ={{1,2,3},{4,5,6}};

5.2 数组指针

数组名实际是指向数组中第一个元素的常量指针

double runoobAarray[50];

其中的runoobAarray 可以看做是一个指向 &runoobAarray[0] 的指针，数组 runoobAarray 的第一个元素的地址。

可以把指针 p 赋值为 runoobAarray 的第一个元素的地址：

double *p;double runoobAarray[10];p = runoobAarray;

使用数组名作为常量指针是合法的，反之亦然。

*(runoobAarray + 4) 是一种访问 runoobAarray[4] 数据的合法方式。

当第一个元素的地址存储在 p 中，可以用p、(p+1)、*(p+2) 来依次访问数组的各个元素。

#include <iostream>using namespace std;int main (){// 带有 5 个元素的双精度浮点型数组double runoobAarray[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};double *p;p = runoobAarray;// 输出数组中每个元素的值cout << "使用指针的数组值 " << endl; for ( int i = 0; i < 5; i++ ){cout << "*(p + " << i << ") : ";cout << *(p + i) << endl;}cout << "使用 runoobAarray 作为地址的数组值 " << endl;for ( int i = 0; i < 5; i++ ){cout << "*(runoobAarray + " << i << ") : ";cout << *(runoobAarray + i) << endl;}return 0;}

输出结果：

使用指针的数组值 *(p + 0) : 1000*(p + 1) : 2*(p + 2) : 3.4*(p + 3) : 17*(p + 4) : 50使用 runoobAarray 作为地址的数组值 *(runoobAarray + 0) : 1000*(runoobAarray + 1) : 2*(runoobAarray + 2) : 3.4*(runoobAarray + 3) : 17*(runoobAarray + 4) : 50

6 函数

函数是将一段经常使用的代码封装起来，减少重复代码。每个 C++ 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。

6.1 函数的定义

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

1、返回值类型 – 在函数定义中，一个函数可以返回一个值。

2、函数名 – 给函数起个名称

3、参数表列 – 使用该函数时，传入的数据

4、函数体语句 – 大括号内的代码，函数内需要执行的语句

5、return 表达式 – 和返回值类型挂钩，函数执行完后，返回相应的数据

//函数定义（两数相加）int add(int num1, int num2){int sum = num1 + num2;return sum;}

6.2 函数的调用

创建函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。

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

//函数定义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.3 函数的声明

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

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

//声明可以多次，定义只能一次//声明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.4 函数的参数

如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。

形式参数就是在进入函数时被创建，退出函数时被销毁。

当调用函数时，有三种向函数传递参数的方式：

1. 传值调用：

#include <iostream>using namespace std;// 函数声明void swap(int x, int y);// 函数定义void swap(int x, int y){int temp;temp = x; /* 保存 x 的值 */x = y; /* 把 y 赋值给 x */y = temp; /* 把 x 赋值给 y */return;}int main (){// 局部变量声明int a = 100;int b = 200;cout << "交换前，a 的值：" << a << endl;cout << "交换前，b 的值：" << b << endl;// 调用函数来交换值swap(a, b);cout << "交换后，a 的值：" << a << endl;cout << "交换后，b 的值：" << b << endl;return 0;}

输出结果：

交换前，a 的值： 100交换前，b 的值： 200交换后，a 的值： 100交换后，b 的值： 200

2. 指针调用：

#include <iostream>using namespace std;// 函数声明void swap(int *x, int *y);// 函数定义void swap(int *x, int *y){int temp;temp = *x; /* 保存地址 x 的值 */*x = *y; /* 把 y 赋值给 x */*y = temp; /* 把 x 赋值给 y */return;}int main (){// 局部变量声明int a = 100;int b = 200;cout << "交换前，a 的值：" << a << endl;cout << "交换前，b 的值：" << b << endl;/* 调用函数来交换值* &a 表示指向 a 的指针，即变量 a 的地址 * &b 表示指向 b 的指针，即变量 b 的地址 */swap(&a, &b);cout << "交换后，a 的值：" << a << endl;cout << "交换后，b 的值：" << b << endl;return 0;}

输出结果：

交换前，a 的值： 100交换前，b 的值： 200交换后，a 的值： 200交换后，b 的值： 100

3. 引用调用：

#include <iostream>using namespace std;// 函数声明void swap(int &x, int &y);// 函数定义void swap(int &x, int &y){int temp;temp = x; /* 保存地址 x 的值 */x = y; /* 把 y 赋值给 x */y = temp; /* 把 x 赋值给 y */return;}int main (){// 局部变量声明int a = 100;int b = 200;cout << "交换前，a 的值：" << a << endl;cout << "交换前，b 的值：" << b << endl;/* 调用函数来交换值 */swap(a, b);cout << "交换后，a 的值：" << a << endl;cout << "交换后，b 的值：" << b << endl;return 0;}

输出结果：

交换前，a 的值： 100交换前，b 的值： 200交换后，a 的值： 200交换后，b 的值： 100

7 指针

每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。

7.1 指针变量的定义使用

指针变量和普通变量的区别

普通变量存放的是数据,指针变量存放的是地址指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

int main() {//1、指针的定义int a = 10; //定义整型变量a//指针定义语法： 数据类型 * 变量名 ;int * p;//指针变量赋值 通过 & 符号 获取变量的地址p = &a; //指针指向变量a的地址cout << &a << endl; //打印数据a的地址cout << p << endl; //打印指针变量p ，指针可以记录地址//2、指针的使用//对指针变量解引用，可以操作指针指向的内存//通过*操作指针变量指向的内存 cout << "*p = " << *p << endl;system("pause");return 0;}

7.2 空指针和野指针

1. 空指针：

空指针变量指向内存中编号为0的空间，初始化指针变量。空指针指向的内存是不可以访问的。

int main() {//指针变量p指向内存地址编号为0的空间int * p = NULL;//访问空指针报错 //内存编号0 ~255为系统占用内存，不允许用户访问cout << *p << endl;system("pause");return 0;}

2. 野指针：

野指针变量指向非法的内存空间，野指针不是我们申请的空间，因此不要访问。

int main() {//指针变量p指向内存地址编号为0x1100的空间int * p = (int *)0x1100;//访问野指针报错 cout << *p << endl;system("pause");return 0;}

7.3 const修饰指针

const修饰指针有三种情况：

const修饰指针 — 常量指针 ：指针指向可以改，指针指向的值不可以更改const修饰常量 — 指针常量 ：指针指向不可以改，指针指向的值可以更改const即修饰指针，又修饰常量 ：指针指向和指针指向的值都不可以改

int main() {int a = 10;int b = 10;//const修饰的是指针，指针指向可以改，指针指向的值不可以更改const int * p1 = &a; p1 = &b; //正确//*p1 = 100; 报错//const修饰的是常量，指针指向不可以改，指针指向的值可以更改int * const p2 = &a;//p2 = &b; //错误*p2 = 100; //正确//const既修饰指针又修饰常量const int * const p3 = &a;//p3 = &b; //错误//*p3 = 100; //错误system("pause");return 0;}

7.4 指针、数组

通过指针访问数组内的元素：

int main() {int arr[] = {1,2,3,4,5,6,7,8,9,10 };int * p = arr; //指向数组的指针cout << "第一个元素： " << arr[0] << endl;cout << "指针访问第一个元素： " << *p << endl;for (int i = 0; i < 10; i++){//利用指针遍历数组cout << *p << endl;p++;}system("pause");return 0;}

7.5 指针、函数

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

//值传递void swap1(int a ,int b){int temp = a;a = b; b = temp;}//地址传递void swap2(int * p1, int *p2){int temp = *p1;*p1 = *p2;*p2 = temp;}int main() {int a = 10;int b = 20;swap1(a, b); // 值传递不会改变实参swap2(&a, &b); //地址传递会改变实参cout << "a = " << a << endl;cout << "b = " << b << endl;system("pause");return 0;}

7.6 指针、数组、函数

当数组名传入到函数作为参数时，被退化为指向首元素的指针

//冒泡排序函数void bubbleSort(int * arr, int len) //int * arr 也可以写为int arr[]{for (int i = 0; i < len - 1; i++){for (int j = 0; j < len - 1 - i; j++){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() {int arr[10] = {4,3,6,9,1,2,10,8,7,5 };int len = sizeof(arr) / sizeof(int);bubbleSort(arr, len);printArray(arr, len);system("pause");return 0;}

今天我们就到这里，明天继续努力！

若本篇内容对您有所帮助，请三连点赞，关注，收藏支持下。

创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！

Dragon少年 | 文

如果本篇博客有任何错误，请批评指教，不胜感激 ！