C++ 01-基础知识

（推荐IDE：Microsoft Visual Studio）

一、基础概念
1、变量（用于给一段指定的内存空间起名，方便操作这段内存）
语法：数据类型 变量名 = 初始值;（如：int a = 10;）

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

3、数据类型（在创建变量或常量时，必须要指定出相应的数据类型，否则无法给变量分配内存）
（1）整型（区别：所占的内存空间不同）–> 默认是 int 型
<1> short（短整型）-- 2字节
<2> int（整型）-- 4字节
<3> long（长整型）-- 4字节（Windows），8字节（Linux-64位）
<4> long long（长长整型）-- 8字节

（2）sizeof 关键字（统计数据类型所占的内存大小）
语法：sizeof（ 数据类型 / 变量 ）

（3）实型（浮点型）（用于表示小数，区别：表示的有效数字范围不同）–> 默认是 double 型
<1> float（单精度）-- 4字节（7位有效数字）
<2> double（双精度）-- 8字节（15～16位有效数字）
[科学计数法]
float f1 = 3e2 --> f1 = 3 * 10^2
float f2 = 3e-2 --> f2 = 3 * 0.1^2

（4）字符型（char，用于显示单个字符）-- 1字节
语法：char 变量名 = '变量值'; （注：用单引号将字符括起来，不要用双引号，且单引号内只能有一个字符，不可以是字符串。）
注意：字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元。

（5）转义字符（用于表示一些不能显示出来的ASCII字符）
常用的转义字符：\n（换行）， \（一个反斜线字符\），\t（水平制表符，跳到下一个Tab位置）

（6）字符串型（用于表示一串字符）
两种语法：
char 变量名[ ] = "变量名"; // C风格书写字符串
string 变量名 = "变量名"; // 使用C++风格写字符串时，要在文件顶部加上头文件：#include

（7）布尔类型（bool，用于表示 true（1，或非0值）或 false（0））
语法：bool 变量名 = true（或 false）;

（8）数据的输入（用于从键盘获取数据）
语法：cin >> 变量名;
数据输出：cout << 变量名 << endl;（endl 表示换行）

4、随机数函数：rand() --> 此时是伪随机数
添加随机数种子，利用当前系统时间生成真正的随机数：srand ((unsigned int) time (NULL));
但是要在文件顶部添加 time系统时间头文件：#include <ctime>

5、goto语句（可以无条件跳转语句）
语法：goto 标记; （若标int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int * p = arr;
cout << “利用指针访问第一个元素：” << *p << endl;
p++;
cout记的名称存在，执行到goto语句时，会跳转到标记的位置。）

6、数组（特点：放在一块连续的内存空间中，数组中每个元素都是相同的数据类型）
（1）一维数组：—> 数组名可以统计整个数组在内存中的长度：sizeof (arr)；可以获取数组在内存中的首地址：cout << arr << endl
<1> 数据类型 数组名[数组长度];
<2> 数据类型 数组名[数组长度] = {值1，值2，…};
<3> 数据类型 数组名[ ] = {值1，值2，…};

（2）二维数组：
<1> 数据类型 数组名 [行数] [列数];
<2> 数据类型 数组名 [行数] [列数] = {{数据1, 数据2, …}, {数据3, 数据4, …}};
<3> 数据类型 数组名 [行数] [列数] = {数据1, 数据2, 数据3, 数据4, …};
<4> 数据类型 数组名 [ ] [列数] = {数据1, 数据2, 数据3, 数据4, …};

7、函数（将一段经常使用的代码封装起来，减少重复代码，每个模块实现特定的功能）
（1）语法：

返回值类型 函数名（参数列表）{     // 若该函数不需要返回值，则返回值可以写void。其中参数列表中的参数，即为形参。
	函数体语句;
	。。。
	return表达式;
}

（2）函数的调用：
返回值 = 函数名 (参数1, 参数2, ...); // 其中的参数，即为实参。

（3）函数的声明：（作用：提前告诉编译器函数的名称以及如何调用函数，此时函数的实际主体可以在 mian() 函数之后单独定义。）
语法：返回值类型 函数名 (参数列表);
（注：函数的声明可以多次，但是函数的定义只能有一次。）

（4）函数的分文件编写：（作用：让代码结构更加清晰。）
操作步骤：
<1> 创建后缀名为 .h 的头文件。
<2> 创建后缀名为 .cpp 的源文件。
<3> 在头文件中写函数声明。
<4> 在源文件中写函数的定义。( 在源文件顶部要写上所包含的头文件：#include”头文件名.h“ )

8、指针（作用：可以通过指针间接地访问内存。）
[说明] 内存编号是从0开始记录的，一般使用十六进制数字来表示。可以利用指针变量保存地址。
（1）指针变量定义语法：数据类型 * 指针变量名;
让指针记录普通变量的地址：指针变量 = &普通变量;

（2）使用指针：（可以通过解引用的方式来找到指针指向的内存。）
指针变量名（指针变量名前加 ”“，代表解引用，找到指针指向的内存中的数据，然后可以读取或修改该数据。）

（3）指针所占的内存空间：（不管是什么数据类型的指针变量）
32位操作系统（4个字节）
64位操作系统（8个字节）

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

（5）野指针：指针变量指向非法的内存空间
注意：空指针和野指针都不是我们申请的空间，因此不要访问它。

（6）const 修饰指针：
<1> const 修饰指针 —> 表示：常量指针 （ 例：const int * p = &a ）
特点：此时，指针的指向可以修改，但是指针指向的值不可以修改。
<2> const 修饰常量 —> 表示：指针常量 （ 例：int * const p = &a ）
特点：此时，指针的指向不可以修改，但是指针指向的值可以修改。
<3> const 既修饰指针，又修饰常量 —> （ 例：const int * const p = &a ）
特点：此时，指针的指向和指针指向的值都不可以修改。

（7）指针和数组：（作用：利用指针访问数组中的元素。）

int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int * p = arr;
cout << "利用指针访问数组第一个元素：" << *p << endl;    // *p --> 通过解引用，找到指针指向的内存中的数据
p++;
cout << "利用指针访问数组第二个元素：" << *P << endl;

（8）指针和函数：（作用：利用指针作为函数的参数，可以修改实参的值。）

// 值传递
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;
}

二、结构体
1、基础
（1）概念：结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。
（2）语法：struct 结构体名{ 结构体成员列表 } ; ----> 结构体定义时，struct关键字不可以省略！！
示例：

// 结构体定义
struct Student(
	// 成员列表
	string name; // 姓名
	int age;   // 年龄
	int score;  // 分数
);

（3）创建结构体变量：（三种方式） ----> 创建结构体变量时，struct 关键字可以省略！！
<1> struct 结构体名 变量名;
<2> struct 结构体名 变量名 = {成员1值, 成员2值, ...};
<3> 定义结构体时，顺便创建变量：struct 结构体名 {成员1值, 成员2值, ...} 变量名;
示例：

// 第一种方式创建
struct Student s1;
s1.name = "张三";
s1.age = 18;
s1.score = 100;
// 第二种方式创建
struct Student s2 = {"李四", 19, 80};
// 第三种方式创建(不常用)
struct Student(
	string name; 
	int age;   
	int score;  
) s3;
s3.name = "王五";
s3.age = 20;
s3.score = 60;

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

// 定义结构体
struct Student{
	// 成员列表
	string name;
	int age;
	int score;
};
// 主函数
int main(){
	// 结构体数组
	Student arr[3] = {
		{"张三", 18, 80},
		{"李四", 19, 60},
		{"王五", 20, 80}
	};
	// 遍历结构体数组
	for(int i = 0; i < 3; i++){
		cout << "姓名：" << arr[i].name << "年龄：" << arr[i].age  << "分数：" << arr[i].score << endl;
	}
	system("pause");
	return 0;
}

3、结构体指针
（1）作用：通过指针访问结构体中的成员。
（2）说明：利用操作符 -> 可以通过结构体指针访问结构体属性。
示例：

// 定义结构体
struct Student{
	string name;
	int age;
	int score;
};
// 主函数
int main(){
	Student sthttps://developer.android.google.cn/previewu = {"张三", 18, 100};  // 创建结构体变量
	Student * p = &stu;     // 通过指针指向结构体变量
	// 通过指针访问结构体变量中的数据，需要利用操作符：->
	cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
	system("pause");
	return 0;
}

4、结构体做函数参数
（1）作用：将结构体作为参数向函数中传递
（2）传递方式：（两种）
<1> 值传递
<2> 地址传递
示例：

// 定义结构体
struct Student{https://developer.android.google.cn/preview
	string name;
	int age;
};
// 1.值传递函数
void printStudent1(Student stu){
	stu.age = 28;
	cout << "子函数中姓名：" << stu.name << "年龄：" << stu.age << endl;
}
// 2.地址传递函数
void printStudent2(Student * p){
	p->age = 30;
	cout << "子函数中姓名：" << p->name << "年龄：" << p->age << endl;
}https://developer.android.google.cn/preview
// 主函数
int main(){
	// 创建结构体变量
	Student stu;
	stu.name = "张三";
	stu.age = 20;
	printStudent1(stu);
	printStudent2(&stu);
	cout << "main函数中姓名：" << stu.name << "年龄：" << stu.age << endl;
	
	system("pause");
	return 0;
}

总结：若不想修改主函数中的数据，使用值传递；若需要修改主函数中的数据，使用地址传递。

5、结构体中 const 的使用场景
（1）作用：用于防止函数体中的误操作。
示例：

// const使用场景
void printStudent(const Student * p){      // 将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来。
	p->age = 100;    // 加入const关键字之后，一旦有修改的操作，就会报错，可以防止我们的误操作。
	cout << "姓名：" << p->name << "年龄：" << p-age << endl;
}