# C++ 基础篇

# 变量

变量是程序中用于存储数据的地方。变量的类型决定了变量可以存储的数据类型，以及变量的操作可以进行的操作。

c++变量声明

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10;
	// using namespace std, we can access cout and endl directly
	// 打印变量 a 的值
	cout << "A = " << a << endl;
	}

# 常量

常量是固定值，不能被修改的变量，常量通常用大写字母表示。

常量声明有两种方式：
- 1. 宏常量：使用 #define 关键字定义，通常定义在文件头部。
- 1. 常量声明：使用 const 关键字定义。

c++常量声明一

	#include <iostream>
	// declaring namespace std
	using namespace std;
	//defining macro day, 定义宏常量使用 #define 关键字，通常定义在文件头部
	#define Day 1
	int main() {
	// using namespace std, we can access cout and endl directly
	// 打印 Day 宏常量的值
	cout << "Day = " << Day << endl;
	}

c++常量声明二

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	//const 修饰的变量
	const int month = 12;
	//a = 20; // 编译错误，常量不能被修改
	cout << "一年有多少个月份 "<< month << endl; // 输出 10
	}

# 关键字

关键字：C++ 语言中具有特殊含义的单词，不能用作变量名、常量名、函数名等。
关键字列表：
- auto：声明变量类型，只能用于局部变量。
- break：跳出循环。
- case：选择语句中的一个分支。
- char：字符类型。
- const：常量。
- continue：继续下一轮循环。
- default：选择语句中的默认分支。
- do-while：循环语句。
- double：双精度浮点数类型。
- else：条件语句中的否定分支。
- enum：枚举类型。
- extern：声明变量在其他文件中。
- float：单精度浮点数类型。
- for：循环语句。
- goto：无条件跳转语句。
- if-else：条件语句。
- int：整数类型。
- long：长整数类型。
- register：声明变量在寄存器中。
- return：函数返回语句。
- short：短整数类型。
- signed：有符号整数类型。
- sizeof：获取变量或类型大小。
- static：声明静态变量。
- struct：结构类型。
- switch：选择语句。
- typedef：给类型定义一个新的名称。
- union：联合类型。
- unsigned：无符号整数类型。
- void：空类型。
- volatile：声明变量易变。
- while：循环语句。

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

# 标识符命名规则

标识符：程序中用于表示变量、常量、函数、类、命名空间等名称的符号。
命名规则：
1. 标识符只能由字母、数字和下划线组成，且不能以数字开头。
2. 标识符不能是 C++ 关键字。
3. 标识符的长度不超过 31 个字符。
4. 标识符的命名应易于理解，不要使用拼音、缩写、数字代替英文单词。

# 数据类型

数据类型是程序中用于存储数据的形式，决定了变量可以存储的数据类型，以及变量的操作可以进行的操作。

数据类型分类：
1. 整型：整数类型，包括 char、short、int、long、long long。
2. 浮点型：小数类型，包括 float、double。
3. 字符型：char 类型，包括 char、wchar_t。
4. 布尔型：bool 类型。
5. 指针型：指针类型。
6. 数组型：数组类型。
7. 枚举型：枚举类型。
8. 结构型：结构类型。
9. 共用体型：共用体类型。
10. 联合型：联合类型。
11. 虚基类型：虚基类类型。
12. 其他类型：void 类型。

# 声明

声明：在程序中声明变量或函数，说明变量或函数的类型、名称、作用域、属性等。
语法：类型变量名 = 值；
- 注意：声明时，类型必须与变量实际存储的数据类型一致。
作用域：声明的变量或函数的作用域决定了变量或函数的可见性和生命周期。
属性：
1. 全局变量：全局变量在整个程序中都可以访问，生命周期从程序开始到程序结束。
2. 局部变量：局部变量在函数或块作用域中可以访问，生命周期从声明到函数或块结束。
3. 静态变量：静态变量在整个程序中只初始化一次，生命周期从程序开始到程序结束。
4. 常量：常量的值不能被修改。

c++数据类型声明

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	// 全局变量
	int a = 10;
	// 局部变量
	int b;
	b = 20;
	// 静态变量
	static int c = 30;
	// 常量
	const int d = 40;
	// 打印变量的值
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;
	return 0;
	}

# 整型

整型：整数类型，包括 char、short、int、long、long long。
整型范围：
- char：-128~127。
- short：-32768~32767。
- int：-2147483648~2147483647。
- long：-9223372036854775808~9223372036854775807。
- long long：-18446744073709551616~18446744073709551615。
整型默认值：
- char：0。
- short：0。
- int：0。
- long：0。
- long long：0。
整型大小：
- char：1 字节。
- short：2 字节。
- int：4 字节。
- long：4 字节。
- long long：8 字节。
整型声明：
- 1. 声明变量：类型变量名 = 值；
- 1. 声明多个变量：类型变量名 1 = 值 1, 变量名 2 = 值 2;
- 1. 声明指针变量：类型 * 变量名 = & 变量名；
- 1. 声明常量：const 类型变量名 = 值；

c++整型声明

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	// 声明变量
	int a = 10;
	// 声明多个变量
	int b = 20, c = 30;
	// 声明指针变量
	int *d = &a;
	// 声明常量
	const int e = 40;
	// 打印变量的值
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << *d << endl;
	cout << "e = " << e << endl;
	return 0;
	}

# sizeof 关键字

sizeof 关键字：获取变量或类型大小。
语法：sizeof (类型或变量名)
注意：sizeof 关键字返回的是字节数，而不是单位。

c++_sizeof关键字

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10;
	double b = 20.5;
	// 打印变量 a 的大小
	cout << "a的大小为：" << sizeof(a) << "字节" << endl;
	// 打印变量 b 的大小
	cout << "b的大小为：" << sizeof(b) << "字节" << endl;
	return 0;
	}

# 浮点型

浮点型：小数类型，包括 float、double。
浮点型范围：
float：-3.40282347e+38~3.40282347e+38。
double：-1.7976931348623157e+308~1.7976931348623157e+308。
浮点型默认值：
- float：0.0。
- double：0.0。
浮点型大小：
- float：4 字节。
- double：8 字节。
浮点型声明：
1. 声明变量：类型变量名 = 值；
2. 声明多个变量：类型变量名 1 = 值 1, 变量名 2 = 值 2;
3. 声明指针变量：类型 * 变量名 = & 变量名；
4. 声明常量：const 类型变量名 = 值；

c++浮点型声明

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	// 声明变量
	float a = 3.14f;
	// 声明多个变量
	double b = 20.5, c = 30.5;
	// 声明指针变量
	double *d = &a;
	// 声明常量
	const double e = 40.5;
	// 打印变量的值
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << *d << endl;
	cout << "e = " << e << endl;

	// 科学计数法输出
	float f2 = 3e2; // 3 * 10^2
	cout << "f2 = " << f2 << endl;
	double d2 = 3e-2; // 3 * 10^-2
	cout << "d2 = " << d2 << endl;

	return 0;
	}

# 字符型

字符型：char 类型，包括 char、wchar_t。
字符型范围：
- char：-128~127。
- wchar_t：-32768~32767。
字符型默认值：
- char：'\0'。
- wchar_t：'\0'。
字符型大小：
- char：1 字节。
- wchar_t：2 字节。
字符型声明：
1. 声明变量：类型变量名 = 值；
2. 声明多个变量：类型变量名 1 = 值 1, 变量名 2 = 值 2;
3. 声明指针变量：类型 * 变量名 = & 变量名；
4. 声明常量：const 类型变量名 = 值；

c++字符型声明

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	// 声明变量
	char a = 'a';
	// 声明多个变量
	char b = 'b', c = 'c';
	// 声明指针变量
	char *d = &a;
	// 声明常量
	const char e = 'e';
	// 打印变量的值
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << *d << endl;
	cout << "e = " << e << endl;
	return 0;
	}

# 转义字符

转义字符：在 C++ 中，有一些字符需要用反斜杠进行转义，以表示其特殊含义。
转义字符列表：
- \n：换行符。
- \t：制表符。
- \：反斜杠。
- '：单引号。
- "：双引号。
- ?：问号。
- \a：响铃。
- \b：退格。
- \f：换页。
- \r：回车。
- \v：垂直制表符。

c++转义字符

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	// 输出换行符
	cout << "Hello\nWorld" << endl;
	// 输出制表符
	cout << "Hello\tWorld" << endl;
	// 输出反斜杠
	cout << "Hello\\World" << endl;
	// 输出单引号
	cout << "Hello'World" << endl;
	// 输出双引号
	cout << "Hello\"World" << endl;
	// 输出问号
	cout << "Hello?World" << endl;
	// 输出响铃
	cout << "Hello\aWorld" << endl;
	// 输出退格
	cout << "Hello\bWorld" << endl;
	// 输出换页
	cout << "Hello\fWorld" << endl;
	// 输出回车
	cout << "Hello\rWorld" << endl;
	// 输出垂直制表符
	cout << "Hello\vWorld" << endl;
	return 0;
	}

# 字符串类型

字符串类型：char 类型数组，以 '\0' 结尾。
字符串类型声明：
- 1. 声明变量：char 变量名 [] = "值";
- 1. 声明指针变量：char * 变量名 = "值";
- 1. 声明常量：const char 变量名 [] = "值";
C++11 新增了一种字符串类型：std::string，可以自动管理内存，使用方便。
C 风格字符串：char str [] = "Hello World";
C++ 风格字符串：std::string str = "Hello World";
注意：
- C++ 风格字符串可以自动管理内存，不需要手动释放内存。
- C++ 风格字符串可以直接输出，不需要使用 cout << str << endl;

c++字符串类型

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	// 声明变量
	char str1[] = "Hello World";
	// 声明指针变量
	char *str2 = "Hello World";
	// 声明常量
	const char str3[] = "Hello World";
	// 打印变量的值
	cout << "str1 = " << str1 << endl;
	cout << "str2 = " << str2 << endl;
	cout << "str3 = " << str3 << endl;
	// C++11 新增的字符串类型
	string str4 = "Hello World";
	// 打印变量的值
	cout << "str4 = " << str4 << endl;
	return 0;
	}

# 布尔类型

布尔类型：bool 类型，只有 true 和 false 两个值。
布尔类型声明：
- 1. 声明变量：bool 变量名 = 值；
- 1. 声明指针变量：bool * 变量名 = & 变量名；
- 1. 声明常量：const bool 变量名 = 值；

c++布尔类型

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	// 声明变量
	bool a = true;
	// 声明指针变量
	bool *b = &a;
	// 声明常量
	const bool c = false;
	// 打印变量的值
	cout << "a = " << a << endl;
	cout << "b = " << *b << endl;
	cout << "c = " << c << endl;
	return 0;
	}

# 数据的输入

输入数据：
- cin：从标准输入设备（键盘）读取数据。
- getline：从标准输入设备（键盘）读取一行数据。
- get：从标准输入设备（键盘）读取一个字符。
输出数据：
- cout：输出到标准输出设备（屏幕）。
- put：输出到标准输出设备（屏幕）。
- putchar：输出到标准输出设备（屏幕）。

c++数据的输入输出

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	// 输入数据
	int a;
	double b;
	char c;
	string d;
	// 输出数据
	cout << "请输入整数a：" << endl;
	// 读取输入数据
	cin >> a;
	cout << "请输入小数b：" << endl;
	cin >> b;
	cout << "请输入字符c：" << endl;
	cin >> c;
	cout << "请输入字符串d：" << endl;
	cin >> d;
	// 输出数据
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;
	return 0;
	}

# 运算符

# 加减乘除

加法运算符：+
减法运算符：-
乘法运算符：*
除法运算符：/
取余运算符：%

c++算术运算符

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 加法运算
	int c = a + b;
	cout << "a + b = " << c << endl;
	// 减法运算
	int d = a - b;
	cout << "a - b = " << d << endl;
	// 乘法运算
	int e = a * b;
	cout << "a * b = " << e << endl;
	// 除法运算
	int f = a / b;
	cout << "a / b = " << f << endl;
	// 取余运算
	int g = a % b;
	cout << "a % b = " << g << endl;
	return 0;
	}

# 取余运算符

取余运算符：%
语法：a % b
功能：求 a 除以 b 的余数，即 a - b * (a /b)。
特别注意：
- 取余运算符的结果是整数，向零取整。
- 取余运算符的结果是负数，表示 b 大于 a。

c++取余运算符

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 取余运算
	int c = a % b;
	cout << "a % b = " << c << endl;
	return 0;
	}

# 自增自减运算符

自增运算符：++
自减运算符：--
语法：变量名 ++ 或变量名 --
功能：
- 自增运算符：先将变量的值加 1，然后再返回变量的值。
- 自减运算符：先将变量的值减 1，然后再返回变量的值。

c++自增自减运算符

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 自增运算
	a++;
	cout << "a = " << a << endl;
	b--;
	cout << "b = " << b << endl;
	return 0;
	}

注意：
- 自增自减运算符只能作用于变量，不能作用于常量。
- 自增自减运算符只能作用于整型变量。
- 自增自减运算符只能作用于变量，不能作用于表达式。

c++自增自减运算符注意事项

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	const int a = 10;
	// 自增运算
	a++; // 错误，不能作用于常量
	cout << "a = " << a << endl;
	return 0;
	}

自增自减运算符的前后顺序：
- 前置：++ 变量名或 -- 变量名
- 后置：变量名 ++ 或变量名 --

c++自增自减运算符的前后顺序

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 前置自增运算
	++a;
	cout << "a = " << a << endl;
	// 后置自增运算
	b = b++;
	cout << "b = " << b << endl;
	// 前置自减运算
	--a;
	cout << "a = " << a << endl;
	// 后置自减运算
	b = b--;
	cout << "b = " << b << endl;
	return 0;
	}

# 赋值运算符

赋值运算符：=
语法：变量名 = 值
功能：将右侧的值赋给左侧的变量。

c++赋值运算符

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 赋值运算
	a = b;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return 0;
	}

# 关系运算符

关系运算符：
- ==：等于。
- !=：不等于。
- ：大于。
- <：小于。
- =：大于等于。
- <=：小于等于。

c++关系运算符

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 关系运算
	bool c = (a == b);
	cout << "a == b = " << c << endl;
	c = (a != b);
	cout << "a != b = " << c << endl;
	c = (a > b);
	cout << "a > b = " << c << endl;
	c = (a < b);
	cout << "a < b = " << c << endl;
	c = (a >= b);
	cout << "a >= b = " << c << endl;
	c = (a <= b);
	cout << "a <= b = " << c << endl;
	return 0;
	}

# 逻辑运算符

逻辑运算符：
- &&：逻辑与。
- ||：逻辑或。
- !：逻辑非。
语法：
- 逻辑与：表达式 1 && 表达式 2
- 逻辑或：表达式 1 || 表达式 2
- 逻辑非：! 表达式
功能：
- 逻辑与：只有两个表达式都为真，结果才为真。
- 逻辑或：只要两个表达式有一个为真，结果就为真。
- 逻辑非：取反，如果表达式为真，结果为假；如果表达式为假，结果为真。

c++逻辑运算符

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 逻辑运算
	bool c = (a == b) && (a > b);
	cout << "a == b && a > b = " << c << endl;
	c = (a != b) \|\| (a < b);
	cout << "a != b \|\| a < b = " << c << endl;
	c =!(a == b);
	cout << "!a == b = " << c << endl;
	const int d = 10;
	cout << !!d << endl; // 可以使用逻辑运算符！！对常量进行取反操作
	return 0;
	}

c++逻辑运算符短路特性

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 逻辑与短路特性
	bool c = (a == b) && (a > b);
	cout << "a == b && a > b = " << c << endl;
	c = (a != b) \|\| (a < b);
	cout << "a != b \|\| a < b = " << c << endl;
	c =!(a == b);
	cout << "!a == b = " << c << endl;
	const int d = 10;
	cout << !!d << endl; // 可以使用逻辑运算符！！对常量进行取反操作
	return 0;
	}

# 位运算符

位运算符：
- &：按位与。
- |：按位或。
- ^：按位异或。
- ~：按位取反。
- <<：左移。
- ：右移。
语法：
- &：变量 1 & 变量 2
- |：变量 1 | 变量 2
- ^：变量 1 ^ 变量 2
- _：变量
- <<：变量 << 位数
- ：变量 >> 位数
功能：
- &：两个二进制位都为 1 时，结果才为 1。
- |：两个二进制位中只要有一个为 1，结果就为 1。
- ^：两个二进制位不同时为 1，结果才为 1。
- ~：对二进制位取反，即 0 变 1，1 变 0。
- <<：将二进制位向左移动指定的位数。
- ：将二进制位向右移动指定的位数。

c++位运算符

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 位运算
	int c = a & b;
	cout << "a & b = " << c << endl;
	c = a \| b;
	cout << "a \| b = " << c << endl;
	c = a ^ b;
	cout << "a ^ b = " << c << endl;
	c = ~a;
	cout << "~a = " << c << endl;
	c = a << 2;
	cout << "a << 2 = " << c << endl;
	c = a >> 2;
	cout << "a >> 2 = " << c << endl;
	return 0;
	}

# 程序流程结构

C/C++ 支持最基本的三种程序流程结构：顺序结构、分支结构、循环结构。
- 顺序结构：从上到下依次执行语句。
- 分支结构：选择执行。
- 循环结构：重复执行。
顺序结构：
- 语法： {语句1; 语句2; ...; 语句n;}
- 功能：从上到下依次执行语句。

c++顺序结构示例

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int a = 10, b = 5;
	// 顺序结构
	{
	int c = a + b;
	cout << "a + b = " << c << endl;
	}
	cout << "b = " << b << endl;
	return 0;
	}

# 单行 if 语句

语法： if(条件表达式){语句}
功能：如果条件表达式为真，则执行语句。

c++单行if语句

	#include <iostream>
	// declaring namespace std
	using namespace std;
	int main() {
	int Language, Mathematics;
	cout << "请输入语文成绩："<< endl;
	// 获取输入
	cin >> Language;
	cout << "请输入数学成绩："<< endl;
	cin >> Mathematics;
	if (Language >= 60 && Mathematics >= 60) {
	cout << "你通过了本次考试！" << endl;
	} else {
	cout << "你未通过本次考试！" << endl;
	}
	return 0;
	}

# 多行 if 语句

语法： if(条件表达式){语句1}else{语句2}
功能：如果条件表达式为真，则执行语句 1；否则执行语句 2。

c++多行if语句

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	// 总分
	int score = 0;
	cout << "请输入一个考试分数：" << endl;
	// 获取输入的分数
	cin >> score;
	// 判断分数是否合法
	if (score >= 600) {
	cout << "恭喜你通过了考试！" << endl;
	}else {
	cout << "很遗憾，你未能通过考试！" << endl;
	}
	return 0;

	}

# 多条件 if 语句

语法： if(条件表达式1){语句1}else if(条件表达式2){语句2}...else{语句n}
功能：从上到下依次判断条件表达式，如果第一个表达式为真，则执行第一个语句；如果第一个表达式为假，则判断第二个表达式，如果第二个表达式为真，则执行第二个语句；以此类推，直到找到真值表达式，执行对应的语句。

c++多条件if语句

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	// 总分
	int score = 0;
	cout << "请输入一个考试分数：" << endl;
	// 获取输入的分数
	cin >> score;
	// 判断分数是否合法
	if (score >= 90) {
	cout << "恭喜你通过了考试！" << endl;
	} else if (score >= 80) {
	cout << "你通过了本次考试！" << endl;
	} else if (score >= 60) {
	cout << "你及格了！" << endl;
	} else {
	cout << "很遗憾，你未能通过考试！" << endl;
	}
	return 0;

	// 输出结果：
	// 请输入一个考试分数：
	// 85
	// 你通过了本次考试！
	}

# 嵌套 if 语句

语法： if(条件表达式1){语句1}else if(条件表达式2){语句2}...else{语句n}
功能：从上到下依次判断条件表达式，如果第一个表达式为真，则执行第一个语句；如果第一个表达式为假，则判断第二个表达式，如果第二个表达式为真，则执行第二个语句；以此类推，直到找到真值表达式，执行对应的语句。

c++嵌套if语句

	// 嵌套 if 语句
	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	// 总分
	int score = 0;
	cout << "请输入一个考试分数：" << endl;
	// 获取输入的分数
	cin >> score;
	// 判断分数是否合法
	if (score >= 90) {
	cout << "恭喜你通过了考试！" << endl;
	} else if (score >= 80) {
	cout << "你通过了本次考试！" << endl;
	if (score >= 85) {
	cout << "你优秀！" << endl;
	} else {
	cout << "你及格了！" << endl;
	}
	} else if (score >= 60) {
	cout << "你及格了！" << endl;
	} else {
	cout << "很遗憾，你未能通过考试！" << endl;
	}
	return 0;

	// 输出结果：
	// 请输入一个考试分数：
	// 85
	// 你通过了本次考试！
	// 你优秀！
	}

# 三只小猪称重程序

功能：输入三只小猪的体重，判断谁那只小猪最重。

c++三只小猪称重程序

	// 三只小猪称重程序，使用多重 if 语句和嵌套 if 语句判断谁那只小猪谁最重
	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	// 三只小猪的体重
	int weight1, weight2, weight3;
	cout << "请输入第一只小猪的体重：" << endl;
	cin >> weight1;
	cout << "请输入第二只小猪的体重：" << endl;
	cin >> weight2;
	cout << "请输入第三只小猪的体重：" << endl;
	cin >> weight3;
	// 三只小猪的重量
	int totalWeight = weight1 + weight2 + weight3;
	// 三只小猪的体重
	cout << "第一只小猪的体重：" << weight1 << endl;
	cout << "第二只小猪的体重：" << weight2 << endl;
	cout << "第三只小猪的体重：" << weight3 << endl;
	// 三只小猪的重量
	cout << "三只小猪的总体重：" << totalWeight << endl;
	// 三只小猪的重量
	if (weight1 > weight2) {// 第一只小猪最重
	if (weight1 > weight3) {// 第一只小猪最重
	cout << "第一只小猪最重！" << endl;
	} else {// 第三只小猪最重
	cout << "第三只小猪最重！" << endl;
	}
	} else {// 第二只小猪最重
	if (weight2 > weight3) {// 第二只小猪最重
	cout << "第二只小猪最重！" << endl;
	} else {// 第三只小猪最重
	cout << "第三只小猪最重！" << endl;
	}
	}
	return 0;
	}

# 三目运算符

语法： 表达式1?表达式2:表达式3
功能：如果表达式 1 为真，则返回表达式 2 的值；否则返回表达式 3 的值。
注意：在 C++ 中三目运算符返回的是变量，可以继续赋值

c++三目运算符

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	int a = 10, b = 20, c = 0;
	// 三目运算符
	c = (a > b ? a : b);
	cout << "c = " << c << endl;
	// 在 C++ 中三目运算符返回的是变量，可以继续赋值
	(a > b ? a : b) = 100;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return 0;
	}

# switch 语句

语法： switch(表达式){case 常量1:语句1;break;case 常量2:语句2;break;...default:语句n;break;}
功能：根据表达式的值，选择执行对应的语句。
注意：
- case 后面的常量可以是表达式，也可以是常量。
- break 语句用于结束当前 case 语句，并开始执行下一个 case 语句。
- default 语句是可选的，如果没有匹配到任何 case 语句，则执行 default 语句。

c++switch语句

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	int grade = 0;
	cout << "请输入您的成绩：" << endl;
	// 获取输入的成绩
	cin >> grade;
	//switch 语句
	switch (grade) {
	case 10:
	cout << "超棒" << endl;
	break;
	case 9:
	cout << "优秀" << endl;
	break;
	case 8:
	cout << "良好" << endl;
	break;
	case 7:
	cout << "及格" << endl;
	break;
	case 6:
	cout << "不及格" << endl;
	break;
	default:
	cout << "输入错误" << endl;
	break;
	}
	return 0;
	}

# 循环结构

循环结构：
- while 循环： while(条件表达式){语句}
- do-while 循环： do{语句}while(条件表达式)
- for 循环： for(初始化表达式;条件表达式;循环表达式){语句}
功能：
- while 循环：当条件表达式为真时，执行语句。
- do-while 循环：先执行语句，然后判断条件表达式。
- for 循环：初始化表达式，判断条件表达式，执行语句，循环表达式，直到条件表达式为假。

c++循环结构

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	int i = 0;
	//while 循环
	while (i < 5) {
	cout << "i = " << i << endl;
	i++;
	}
	//do-while 循环
	i = 0;
	do {
	cout << "i = " << i << endl;
	i++;
	} while (i < 5);
	//for 循环
	for (int j = 0; j < 5; j++) {
	cout << "j = " << j << endl;
	}
	return 0;
	}

# 猜数字游戏

功能：用户输入一个数字，计算机根据提示猜测数字。

c++猜数字游戏

	#include <iostream>
	// declaring namespace std
	using namespace std;
	//time 系统时间头文件包含
	#include <ctime>
	int main() {
	// 添加随机数种子，保证每次运行程序生成的随机数相同
	srand((unsigned int)time(nullptr));
	// 生成随机数
	int random_number = rand() % 100 + 1;
	int user_input;
	while (true){
	cout << "请猜一个数字: ";
	// 获取用户输入
	cin >> user_input;
	// 判断用户输入是否正确
	if (user_input == random_number) {
	cout << "恭喜你，猜对了！" << endl;
	} else if (user_input < random_number) {
	cout << "你猜的数字小了，再接再厉！" << endl;
	} else if (user_input > random_number){
	cout << "你猜的数字大了，再接再厉！" << endl;
	}else {
	cout << "很遗憾，猜错了！正确答案是" << random_number << endl;
	return 0;
	}
	}
	}

# do-while 循环

语法： do{语句}while(条件表达式)
功能：先执行语句，然后判断条件表达式。
注意：do-while 循环至少执行一次语句。

c++do-while循环

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	int i = 0;
	//do-while 循环
	do {
	cout << "i = " << i << endl;
	i++;
	} while (i < 5);
	//do...while 与 while 的区别在于，do...while 循环至少执行一次语句。
	return 0;
	}

# 水仙花数

功能：输入一个 3 位数，判断是否为水仙花数。
水仙花数：一个 n 位数，它的每个位上的数字的 n 次幂之和等于这个数本身。
例如：153 是一个 3 位数，它的每个位上的数字的 3 次幂之和等于这个数本身，即 1^3 + 5^3 + 3^3 = 153。

c++水仙花数

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	int num;
	cout << "请输入一个3位数：" << endl;
	cin >> num;
	int gewei = num / 100;
	int shiwei = (num % 100) / 10;
	int baiwei = num % 10;
	int sum = gewei * gewei * gewei + shiwei * shiwei * shiwei + baiwei * baiwei * baiwei;
	if (sum == num) {
	cout << num << "是水仙花数！" << endl;
	} else {
	cout << num << "不是水仙花数！" << endl;
	}
	return 0;
	}

使用 do-while 实现水仙花数游戏

c++do-while实现水仙花数游戏

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	int num = 100;
	do {
	int gewei = 0;// 个位数
	int shiwei = 0;// 十位数
	int baiwei = 0;// 百位数
	gewei = num % 10;// 取个位数
	shiwei = num / 10 % 10;// 取十位数
	baiwei = num / 100;// 取百位数
	if (gewei * gewei * gewei + shiwei * shiwei * shiwei + baiwei * baiwei * baiwei == num) {
	cout << num << endl;
	}
	num++;
	} while (num < 1000);
	return 0;
	}

# for 循环

语法： for(初始化表达式;条件表达式;循环表达式){语句}
功能：初始化表达式，判断条件表达式，执行语句，循环表达式，直到条件表达式为假。
注意：
- 初始化表达式：在循环开始之前执行一次。
- 循环表达式：在每次循环结束后执行一次。
- 条件表达式：循环条件，当其为真时，循环继续，当其为假时，循环结束。

c++for循环

	#include <iostream>
	// declaring namespace std
	using namespace std;

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

# 敲桌子游戏

功能：从这 100 个数字中找到特殊数字，改为 “敲桌子:”
特殊数字：
- 能被 7 整除的数字
- 能被 10 整除的数字
- 能被 70 整除的数字

c++敲桌子游戏

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	for (int i = 1; i <= 100; i++) {
	cout << ((i % 10 == 7 \|\| i / 10 == 7 \|\| i % 7 == 0) ? "敲桌子" : to_string(i)) << endl;
	}
	return 0;
	}

# 九九乘法表

功能：打印九九乘法表。

c++九九乘法表

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	for (int i = 1; i <= 9; i++) {
	for (int j = 1; j <= i; j++) {
	cout << i << "x" << j << "=" << i * j << "\t";
	}
	cout << endl;
	}
	return 0;
	}

# 打印矩形

c++打印矩形

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	for (int i = 1; i <= 10; i++) {
	for (int j = 1; j <= 10; j++) {
	cout << "*"<< " ";
	}
	cout << endl;
	}
	return 0;
	}

# 斐波那契数列

功能：打印斐波那契数列。

c++斐波那契数列

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	int a = 0, b = 1, c;
	cout << a << " " << b << " ";
	for (int i = 2; i < 10; i++) {
	c = a + b;
	cout << c << " ";
	a = b;
	b = c;
	}
	return 0;
	}

# break 跳出循环

语法： break;
功能：跳出当前循环。

c++break跳出循环

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	int i = 0;
	while (true) {
	cout << "i = " << i << endl;
	i++;
	if (i == 5) {
	break;
	}
	}
	return 0;
	}

# continue 跳过本次循环

语法： continue;
功能：跳过本次循环，继续执行下一次循环。

c++continue跳过本次循环

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	for (int i = 0; i < 5; i++) {
	if (i == 2) {
	continue;
	}
	cout << "i = " << i << endl;
	}
	return 0;
	}

# goto 跳转语句

语法： goto 标签;
功能：跳转到指定标签处执行。

c++goto语句

	#include <iostream>
	// declaring namespace std
	using namespace std;

	int main() {
	int i = 0;
	start:
	cout << "i = " << i << endl;
	i++;
	if (i < 5) {
	goto start;
	}
	return 0;
	}