C++简明教程（文章要求学过一点C语言）（5）

在开始之前必须阅读这个文章
https://blog.csdn.net/weixin_45100742/article/details/135152562

这篇文章完全是对C语言的补课，如果C语言学的好，可跳过。

变量、数据类型与运算符

在 C++ 编程中，理解变量、数据类型和运算符是构建程序的基石。本教程将详细介绍这些基础概念，并通过示例代码帮助你更好地掌握。

一、C++ 语法基础

分号与大小写敏感性

在 C++ 中，每一条语句都必须以分号 ; 结尾，分号是语句结束的标志，编译器依靠它来识别一条语句的结束位置。例如：

int num = 5;  // 这是一个完整的语句，声明并初始化一个整数变量 num，末尾的分号表示语句结束
std::cout << "Hello";  // 输出语句，用于向控制台输出字符串 "Hello"，同样以分号结尾

C++ 是区分大小写的语言，这意味着变量名、函数名、关键字等标识符，大写和小写字母被视为不同的符号。例如：
```
int num = 10;
int Num = 20;  // num 和 Num 是不同的变量，编译器会将它们区分对待
```

二、变量

变量的含义
- 变量是程序中用于存储数据的容器，它就像一个盒子，可以存放各种类型的数据，如数字、字符、字符串等。在程序运行过程中，变量的值可以根据需要进行改变，这使得程序能够根据不同的情况进行灵活的处理。例如，我们可以使用一个变量来存储用户输入的年龄，或者计算过程中的中间结果。

变量的声明

在使用变量之前，必须先进行声明，声明变量的目的是告诉编译器变量的数据类型和名称，以便编译器为其分配相应的内存空间。变量声明的基本语法是：数据类型变量名;。例如：

int age;  // 声明一个名为 age 的整数变量，此时变量的值是未定义的，可能是内存中的任意值
char grade;  // 声明一个名为 grade 的字符变量
float price;  // 声明一个名为 price 的单精度浮点数变量

变量的初始化

初始化是在声明变量的同时给它赋一个初始值，这是一个良好的编程习惯，可以避免变量在未初始化的情况下被使用，从而产生不可预测的结果。例如：

int count = 0;  // 声明并初始化为 0
float temperature = 25.5f;  // 声明并初始化为 25.5，注意单精度浮点数常量后面要加 f 后缀，以区分双精度浮点数
char symbol = 'A';  // 声明并初始化为字符 'A'

变量的使用

一旦变量被声明和初始化（或者赋值），我们就可以在程序中使用它来存储和操作数据。例如：

int num1 = 5;
int num2 = 3;
int sum = num1 + num2;  // 使用 num1 和 num2 进行加法运算，并将结果存储在 sum 中
std::cout << "The sum is: " << sum << std::endl;  // 输出 sum 的值
num1 = 10;  // 给 num1 重新赋值为 10

三、数据类型

整数类型
- int（有符号整数）：这是最常用的整数数据类型，通常占用 4 个字节（32 位）的内存空间，在大多数现代计算机系统中，它可以表示的范围大致为 -2147483648 到 2147483647。例如：
```
int number = 100;  // 存储一个整数值 100
```
- unsigned int（无符号整数）：与 int 不同，unsigned int 只能表示非负整数，它的取值范围是 0 到 4294967295（同样占用 4 个字节）。例如：
```
unsigned int positiveNumber = 200U;  // 注意无符号整数常量后面要加 U 后缀，用于明确表示这是一个无符号数
```
- short（短整数）：通常占用 2 个字节（16 位），有符号 short 的取值范围大致为 -32768 到 32767，无符号 short 的取值范围为 0 到 65535。例如：
```
short smallNumber = 32767;  // short 类型的最大值
unsigned short unsignedSmallNumber = 65535U;  // 无符号 short 类型的最大值
```
- long（长整数）：在不同的系统上，long 占用的字节数可能不同，一般在 32 位系统上占用 4 个字节，与 int 相同；在 64 位系统上可能占用 8 个字节，能够表示更大范围的整数。有符号 long 的最小值和最大值依赖于系统，无符号 long 同理。例如：
```
long bigNumber = 2147483648L;  // 注意 long 类型常量后面要加 L 后缀，这里表示一个较大的整数，在 32 位系统上可能会超出 int 的范围
unsigned long unsignedBigNumber = 4294967295UL;  // 无符号 long 类型常量加 UL 后缀
```
- long long（长长整数）：通常占用 8 个字节（64 位），有符号 long long 的取值范围非常大，大致为 -9223372036854775808 到 9223372036854775807，无符号 long long 的取值范围为 0 到 18446744073709551615。例如：
```
long long veryBigNumber = 9223372036854775807LL;  // 注意 long long 类型常量后面要加 LL 后缀
unsigned long long unsignedVeryBigNumber = 18446744073709551615ULL;  // 无符号 long long 类型常量加 ULL 后缀
```
字符类型
- char（字符）：用于存储单个字符，如字母、数字、标点符号等，它占用 1 个字节的内存空间。例如：
```
char letter = 'A';  // 存储字符 'A'
char digit = '5';  // 存储字符 '5'
char punctuation = '.';  // 存储标点符号 '.'
```
- 字符在计算机中是以 ASCII 码（美国信息交换标准代码）的形式存储的，每个字符都对应一个唯一的整数值。例如，字符 ‘A’ 的 ASCII 码值是 65，我们可以通过将字符变量以整数形式输出查看其 ASCII 码值：
```
std::cout << "The ASCII value of " << letter << " is: " << (int)letter << std::endl;
```
浮点类型
- float（单精度浮点数）：占用 4 个字节的内存空间，用于表示带有小数部分的数值。它可以表示的精度有限，大约为 6 - 7 位有效数字。例如：
```
float pi = 3.14159f;  // 注意单精度浮点数常量后面要加 f 后缀，以区分双精度浮点数
float temperature = 25.5f;  // 存储一个单精度浮点数温度值
```
- double（双精度浮点数）：占用 8 个字节，比 float 能够表示更精确的小数数值，大约有 15 - 16 位有效数字。在 C++ 中，如果没有特别指定，浮点常量默认为 double 类型。例如：
```
double morePrecisePi = 3.141592653589793;  // 双精度浮点数可以更精确地表示圆周率
double anotherNumber = 123.456789;  // 存储一个双精度浮点数
```
  推荐看看这个篇文章
  https://blog.csdn.net/weixin_46531416/article/details/120756273
布尔类型
- bool（布尔）：用于表示逻辑值，只有两个可能的取值：true（真）和 false（假），它通常占用 1 个字节的内存空间。例如：
```
bool isTrue = true;
bool isFalse = false;
```
- 布尔类型常用于条件判断语句中，如 if 语句，根据布尔值的真假来决定程序的执行路径。例如：
```
if (isTrue) {
    std::cout << "The condition is true." << std::endl;
} else {
    std::cout << "The condition is false." << std::endl;
}
```

四、基本运算符

算术运算符
- 加法（+）、减法（-）、乘法（*）、除法（/）：这些运算符用于基本的数学运算，操作数通常为整数或浮点数类型。例如：
```
int num1 = 10;
int num2 = 3;
int sum = num1 + num2;  // 加法，结果为 13
int difference = num1 - num2;  // 减法，结果为 7
int product = num1 * num2;  // 乘法，结果为 30
int quotient = num1 / num2;  // 除法，整数除法会舍去小数部分，结果为 3
float num3 = 5.0f;
float num4 = 2.0f;
float divisionResult = num3 / num4;  // 浮点数除法，结果为 2.5f
```
- 取余（%）：用于求两个整数相除的余数，操作数必须为整数类型。例如：
```
int remainder = 10 % 3;  // 结果为 1
```
- 自增（++）和自减（--）：这两个运算符用于将变量的值增加或减少 1。++ 可以放在变量前面（前置自增）或后面（后置自增），-- 同理。前置自增会先将变量的值增加 1，然后再使用变量的值；后置自增会先使用变量的值，然后再将变量的值增加 1。例如：
```
int num = 5;
int result1 = ++num;  // 前置自增，num 先变为 6，result1 的值为 6
int result2 = num++;  // 后置自增，result2 的值为 6（num 先被使用，然后变为 7）
```
- 注意事项：在进行除法运算时，如果两个操作数都是整数，结果将是整数除法的结果，舍去小数部分。如果需要得到精确的浮点数结果，至少有一个操作数应该是浮点数类型。另外，自增和自减运算符可能会使代码的可读性变差，在复杂的表达式中要谨慎使用，避免产生意想不到的结果。
赋值运算符
- 基本赋值（=）：用于将右侧表达式的值赋给左侧的变量。例如：
```
int num = 10;  // 将 10 赋值给变量 num
float price = 9.99f;  // 将 9.99 赋值给变量 price
```
- 复合赋值运算符（+=、-=、*=、/=、%= 等）：这些运算符是基本赋值运算符和算术运算符的组合，用于简化变量的更新操作。例如：
```
int num = 5;
num += 3;  // 等价于 num = num + 3，结果为 8
num *= 2;  // 等价于 num = num * 2，结果为 16
```
逻辑运算符
- 逻辑与（&&）、逻辑或（||）、逻辑非（!）：这些运算符用于逻辑判断，操作数通常为布尔类型，常用于条件语句中。逻辑与只有当两个操作数都为真时结果才为真；逻辑或只要有一个操作数为真结果就为真；逻辑非用于取反操作数的逻辑值。例如：
```
bool condition1 = true;
bool condition2 = false;
bool resultAnd = condition1 && condition2;  // 结果为 false
bool resultOr = condition1 || condition2;  // 结果为 true
bool resultNot =!condition1;  // 结果为 false
```
- 注意事项：在使用逻辑与和逻辑或运算符时，要注意短路求值的特性。对于逻辑与，如果第一个操作数为假，则不会计算第二个操作数，因为整个表达式已经确定为假；对于逻辑或，如果第一个操作数为真，则不会计算第二个操作数，因为整个表达式已经确定为真。这在某些情况下可以提高程序的效率，但也可能会产生一些意想不到的结果，需要谨慎使用。
位移运算符
- 左移（<<）和右移（>>）：位移运算符用于将二进制位进行移动，操作数通常为整数类型。左移运算符将操作数的二进制位向左移动指定的位数，右边用 0 填充；右移运算符将操作数的二进制位向右移动指定的位数，对于无符号数，左边用 0 填充，对于有符号数，左边的填充取决于具体的编译器实现（通常是用符号位填充）。例如：
```
int num = 5;  // 二进制表示为 00000101
int leftShifted = num << 2;  // 左移 2 位，结果为 20（二进制表示为 00010100）
int rightShifted = num >> 1;  // 右移 1 位，结果为 2（二进制表示为 00000010）
```
- 注意事项：位移运算符在处理有符号整数时，右移操作可能会导致符号位的变化，从而产生意想不到的结果。在实际应用中，要确保对位移操作的理解和使用是正确的，尤其是在涉及到有符号数的情况下。
运算优先级
- 在 C++ 中，运算符有一定的运算优先级，就像数学中的四则运算先乘除后加减一样。例如，乘法和除法的优先级高于加法和减法，括号可以改变运算的优先级。完整的运算符优先级顺序如下（从高到低）：
  - 括号 ()
  - 后缀自增和自减（如 ++i、--i）、函数调用、数组下标访问等
  - 前缀自增和自减（如 i++、i--）、逻辑非 !、按位取反 ~、正号 +、负号 -
  - 乘法 *、除法 /、取余 %
  - 加法 +、减法 -
  - 左移 <<、右移 >>
  - 小于 <、小于等于 <=、大于 >、大于等于 >=
  - 等于 ==、不等于 !=
  - 按位与 &
  - 按位异或 ^
  - 按位或 |
  - 逻辑与 &&
  - 逻辑或 ||
  - 条件运算符 ?:
  - 赋值运算符（=、+=、-= 等）
  - 逗号运算符 ,
- 例如：
```
int result = 2 + 3 * 4;  // 先计算乘法，结果为 14（而不是 20）
int resultWithParentheses = (2 + 3) * 4;  // 先计算括号内的加法，结果为 20
```
- 注意事项：虽然运算符有明确的优先级顺序，但为了提高代码的可读性和可维护性，建议在复杂的表达式中使用括号来明确运算的顺序，避免因优先级问题导致的错误。

必看这篇
https://blog.csdn.net/weixin_46531416/article/details/120387902

C++ 变量生命周期与修饰关键字详解

在 C++ 编程中，理解变量的生命周期以及用于修饰变量的关键字至关重要，这有助于我们更精准地控制变量的行为和内存使用，编写出更健壮、高效的代码。

一、变量的生命周期

基于作用域的生命周期
- 在 C++ 中，变量的生命周期通常由其所在的作用域决定，而作用域在代码中通过花括号 {} 来界定。当程序执行进入一个包含变量声明的作用域时，该变量被创建（即分配内存空间）；当程序执行离开这个作用域时，变量被销毁（其占用的内存空间被释放），这一过程就是变量的生命周期。
- 例如：
```
{
    int num = 10;  // num 在这个花括号内被创建，生命周期开始
    std::cout << num << std::endl;  // 输出 10
}  // 程序离开这个花括号，num 的生命周期结束，其占用的内存被释放
```

不同作用域中的重名变量

由于变量的生命周期是基于作用域的，所以在不同的作用域（由不同的 {} 界定）中可以定义重名的变量。例如：

int main() {
    int num = 5;  // 第一个 num，生命周期从这里开始
    std::cout << "Outer num: " << num << std::endl;  // 输出 Outer num: 5
    {
        int num = 10;  // 第二个 num，与第一个 num 处于不同的作用域，生命周期从这里开始
        std::cout << "Inner num: " << num << std::endl;  // 输出 Inner num: 10
    }  // 内层的 num 生命周期结束
    std::cout << "Outer num again: " << num << std::endl;  // 输出 Outer num again: 5，外层的 num 不受内层重名变量的影响
    return 0;
}

二、修饰变量的关键字

const 关键字
- 含义与作用：const 关键字用于修饰变量，表示该变量是常量，即其值在初始化后不能被修改。这有助于增强程序的安全性和可读性，避免因意外修改数据而导致的错误。
- 示例代码：
```
const float pi= 3.1415926;  // 定义一个常量 MAX_VALUE，其值不能被改变
// pi= 3.14;  // 这行代码会导致编译错误，因为试图修改常量的值
```
static 关键字
- 局部静态变量：
  - 含义与作用：当 static 关键字用于修饰局部变量时，该变量就成为了局部静态变量。与普通局部变量不同，局部静态变量的生命周期贯穿整个程序的运行过程，但其作用域仍然局限于定义它的函数内部。这意味着它在第一次进入函数时被初始化，并且在函数多次调用之间保持地址不变，也就是不会释放内存，也就是第二次执行 static int count = 0;是不起作用的，因为count 已经定义过了，而不是像普通局部变量那样每次函数调用时都重新创建和初始化。
  - 示例代码：
```
void incrementCounter() {
    static int count = 0;  // 局部静态变量 count，初始化为 0
    count++;
    std::cout << "Count: " << count << std::endl;
}
int main() {
    incrementCounter();  // 输出 Count: 1
    incrementCounter();  // 输出 Count: 2
    incrementCounter();  // 输出 Count: 3
    return 0;
}
```

C++ 流程控制语句详解

一、`if-else` 语句

基本语法和示例：
if-else 语句用于根据条件执行不同的代码块。语法如下：

if (condition) {
    // 如果 condition 为真，执行这里的代码
} else {
    // 如果 condition 为假，执行这里的代码
}

例如，判断一个数是否大于 10：

int num;
std::cout << "请输入一个整数：";
std::cin >> num;

if (num > 10) {
    std::cout << num << " 大于 10。" << std::endl;
} else {
    std::cout << num << " 小于等于 10。" << std::endl;
}

注意事项：
- condition 必须是一个能够求值为布尔值（true 或 false）的表达式。在 C++ 中，非零值被视为 true，零值被视为 false。
- 花括号 {} 的使用很重要，即使代码块只有一行，也建议使用花括号，以增强代码的可读性和可维护性，避免因后续添加代码时忘记添加花括号而导致逻辑错误。

二、`if-else` 分支嵌套

语法和示例：
当需要根据多个条件进行更复杂的判断时，可以使用 if-else 嵌套。语法如下：

if (condition1) {
    // 如果 condition1 为真，执行这里的代码
    if (condition2) {
        // 如果 condition1 和 condition2 都为真，执行这里的代码
    } else {
        // 如果 condition1 为真但 condition2 为假，执行这里的代码
    }
} else {
    // 如果 condition1 为假，执行这里的代码
    if (condition3) {
        // 如果 condition1 为假且 condition3 为真，执行这里的代码
    } else {
        // 如果 condition1 和 condition3 都为假，执行这里的代码
    }
}

例如，判断一个年份是否为闰年（简化版，暂不考虑世纪闰年的精确判断）：

int year;
std::cout << "请输入一个年份：";
std::cin >> year;

if (year % 4 == 0) {
    std::cout << year << " 是闰年。" << std::endl;
} else {
    std::cout << year << " 不是闰年。" << std::endl;
}

注意事项：
- 嵌套层数不宜过多，过多的嵌套会使代码难以阅读和理解，容易出现逻辑错误。一般建议尽量将复杂的条件判断分解成多个简单的 if-else 语句，或者考虑使用其他更合适的算法或数据结构来实现需求。
- 注意每个 if 和 else 的配对关系，可以通过适当的缩进使代码结构清晰，避免因配对错误而导致的逻辑混乱。

三、循环语句

for 循环
- 基本语法和示例：
  for 循环用于在已知循环次数的情况下重复执行一段代码。语法如下：

for (初始化表达式; 条件表达式; 更新表达式) {
    // 循环体，只要条件表达式为真，就会重复执行这里的代码
}

例如，计算 1 到 5 的整数和：

int sum = 0;
for (int i = 1; i <= 5; i++) {
    sum += i;
}
std::cout << "1 到 5 的和为：" << sum << std::endl;

- **注意事项**：
    - 初始化表达式只会在循环开始前执行一次，用于初始化循环变量。
    - 条件表达式在每次循环迭代开始前被求值，如果为假，则循环结束。
    - 更新表达式在每次循环迭代结束后执行，用于更新循环变量的值。
    - 循环变量的作用域通常局限于 `for` 循环内部，在循环外部无法直接访问（除非在循环外提前声明）。

while 循环
- 基本语法和示例：
  while 循环用于在条件为真时重复执行一段代码，条件在每次循环开始前进行检查。语法如下：

while (condition) {
    // 循环体，只要 condition 为真，就会重复执行这里的代码
}

例如，使用 while 循环实现上述计算 1 到 5 的整数和：

int sum = 0;
int i = 1;
while (i <= 5) {
    sum += i;
    i++;
}
std::cout << "1 到 5 的和为：" << sum << std::endl;

- **注意事项**：
    - 要确保循环条件在某个时刻会变为假，否则会导致无限循环，使程序陷入死锁状态。
    - 在循环体中必须有能够改变循环条件的语句，否则循环将永远不会结束。

do-while 循环
- 基本语法和示例：
  do-while 循环与 while 循环类似，但它会先执行一次循环体，然后再检查条件。语法如下：

do {
    // 循环体，先执行一次，然后再判断条件
} while (condition);

例如，使用 do-while 循环实现一个简单的猜数字游戏（简化版，假设数字固定为 5），让用户不断猜测直到猜对为止：

int guess;
do {
    std::cout << "请猜一个数字：";
    std::cin >> guess;
    if (guess > 5) {
        std::cout << "太大了！" << std::endl;
    } else if (guess < 5) {
        std::cout << "太小了！" << std::endl;
    }
} while (guess!= 5);
std::cout << "恭喜你，猜对了！" << std::endl;

- **注意事项**：
    - 由于循环体至少会执行一次，所以在某些情况下可能会导致不必要的操作，因此要根据具体需求选择合适的循环结构。
    - 同样要注意循环条件的正确性，避免无限循环。

四、循环嵌套

语法和示例（以 for 循环嵌套为例）：
循环嵌套是指在一个循环内部再放置另一个循环。语法如下：

for (初始化表达式 1; 条件表达式 1; 更新表达式 1) {
    // 外层循环体
    for (初始化表达式 2; 条件表达式 2; 更新表达式 2) {
        // 内层循环体
    }
}

例如，使用嵌套的 for 循环打印一个简单的乘法口诀表（只到 3×3）：

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= i; j++) {
        std::cout << j << " × " << i << " = " << i * j << "\t";
    }
    std::cout << std::endl;
}

注意事项：
- 循环嵌套会增加代码的执行时间和复杂度，尤其是当嵌套层数较多且循环次数较大时。因此，在实际应用中，要谨慎使用循环嵌套，尽量优化算法，减少不必要的循环操作。
- 注意内层循环和外层循环的变量命名，避免混淆和冲突。同时，要确保内层循环的初始化和更新操作不会影响外层循环的正常执行。

五、`break` 和 `continue` 语句

break 语句
- 语法和示例：
  break 语句用于立即跳出当前所在的循环（for、while、do-while）或 switch 语句。例如，在一个循环中查找一个特定的数字（假设为 7），当找到时就使用 break 结束循环：

int num = 1;
while (num <= 10) {
    if (num == 7) {
        std::cout << "找到了数字 7。" << std::endl;
        break;
    }
    num++;
}

- **注意事项**：
    - `break` 只会跳出最内层的循环或 `switch` 语句，如果存在多层嵌套，只会跳出包含 `break` 语句的那一层，而不会跳出所有嵌套的循环。
    - 在某些情况下，过度使用 `break` 可能会使代码的逻辑变得不清晰，因此应谨慎使用，确保其使用场景符合代码的逻辑结构和意图。

continue 语句
- 语法和示例：
  continue 语句用于跳过当前循环迭代中剩余的代码，直接进入下一次循环迭代。例如，打印 1 到 10 中的奇数：

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    std::cout << i << " ";
}

- **注意事项**：
    - 与 `break` 类似，`continue` 也只影响当前所在的循环层。
    - 使用 `continue` 时要注意循环变量的更新和条件判断，确保不会因为跳过某些迭代而导致逻辑错误，例如在循环中遗漏了对某些变量的必要更新操作，从而使循环条件永远无法满足或出现异常情况。

六、`switch` 语句

基本语法和示例：
switch 语句用于根据一个表达式的不同取值执行不同的代码块。语法如下：

switch (表达式) {
    case 常量表达式 1:
        // 当表达式的值等于常量表达式 1 时执行的语句块
        break;
    case 常量表达式 2:
        // 当表达式的值等于常量表达式 2 时执行的语句块
        break;
    //...
    default:
        // 当表达式的值与所有常量表达式都不匹配时执行的语句块
        break;
}

例如，根据用户输入的数字输出对应的星期几（简化版，只考虑 1 - 5）：

int day;
std::cout << "请输入一个数字（1 - 5）：";
std::cin >> day;

switch (day) {
    case 1:
        std::cout << "星期一" << std::endl;
        break;
    case 2:
        std::cout << "星期二" << std::endl;
        break;
    case 3:
        std::cout << "星期三" << std::endl;
        break;
    case 4:
        std::cout << "星期四" << std::endl;
        break;
    case 5:
        std::cout << "星期五" << std::endl;
        break;
    default:
        std::cout << "无效的输入！" << std::endl;
        break;
}

注意事项：
- switch 后面括号内的表达式必须是整数类型（包括 char 类型）或能够隐式转换为整数类型的表达式，不能是浮点数、字符串等其他类型。
- 每个 case 后面的常量表达式必须是唯一的，否则会导致编译错误。
- 不要忘记在每个 case 语句块的末尾加上 break 语句（除非有意让程序 fall-through，即不添加 break 使程序继续执行下一个 case 的代码，但这种情况应添加清晰的注释说明意图，以免造成误解和逻辑错误），否则程序会继续执行下一个 case 的语句块，这可能不是预期的行为。