（接上篇）

流程控制结构

条件语句

在 C++ 编程中，条件语句就像是一个智能的决策工具，它能够根据不同的条件来决定程序的执行路径，就好比我们在生活中会根据不同的情况做出不同的选择一样。条件语句主要包括if - else语句和switch - case语句，它们在编程中起着至关重要的作用。

if - else语句是最基本的条件判断语句，它的基本语法如下：

if (条件表达式) {

// 当条件表达式为真时执行的代码块

} else {

// 当条件表达式为假时执行的代码块

}

在这个语法结构中，if后面的括号内是一个条件表达式，它会返回一个布尔值（true或false）。如果条件表达式的值为true，那么程序就会执行if后面花括号内的代码块；如果条件表达式的值为false，则会执行else后面花括号内的代码块。例如，我们可以用if - else语句来判断一个数是否为正数：

int num = 10;

if (num > 0) {

cout << num << " 是正数" << endl;

} else {

cout << num << " 不是正数" << endl;

}

在这个例子中，变量num的值为 10，num > 0这个条件表达式的值为true，所以程序会执行if后面的代码块，输出 “10 是正数”。

if - else语句还可以进行多级判断，通过else if来实现。其语法格式如下：

if (条件表达式1) {

// 当条件表达式1为真时执行的代码块

} else if (条件表达式2) {

// 当条件表达式1为假且条件表达式2为真时执行的代码块

} else if (条件表达式3) {

// 当条件表达式1和2都为假且条件表达式3为真时执行的代码块

} else {

// 当所有条件表达式都为假时执行的代码块

}

这种多级判断结构在处理多种不同情况时非常有用。比如，我们要根据学生的考试成绩来评定等级：

int score = 85;

if (score >= 90) {

cout << "成绩等级为A" << endl;

} else if (score >= 80) {

cout << "成绩等级为B" << endl;

} else if (score >= 70) {

cout << "成绩等级为C" << endl;

} else if (score >= 60) {

cout << "成绩等级为D" << endl;

} else {

cout << "成绩等级为E，不及格" << endl;

}

在这个例子中，根据score的值，程序会依次判断各个条件表达式，找到符合条件的代码块并执行。如果score为 85，那么score >= 90为false，score >= 80为true，所以会执行第二个else if后面的代码块，输出 “成绩等级为 B”。

switch - case语句则是用于多分支选择的结构，它根据一个表达式的值来决定执行多个分支中的哪一个。其基本语法如下：

switch (表达式) {
    case 常量表达式1:
	// 当表达式的值等于常量表达式1时执行的代码块
	break;
   case 常量表达式2:
       // 当表达式的值等于常量表达式2时执行的代码块
       break;
   // 可以有更多的case分支
   default:
       // 当表达式的值与所有case后的常量表达式都不相等时执行的代码块
       break;
}

在switch语句中，首先计算switch后面括号内表达式的值，然后将这个值与各个case后面的常量表达式进行比较。如果找到匹配的case，就会执行该case后面的代码块，直到遇到break语句或者switch语句结束。如果没有找到匹配的case，则会执行default分支（如果存在）。例如，我们可以用switch - case语句来根据用户输入的数字输出对应的星期几：

int day = 3;

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

在这个例子中，day的值为 3，所以会执行case 3后面的代码块，输出 “星期三”。这里的break语句非常重要，它用于跳出switch语句，如果没有break语句，当day为 3 时，除了会执行case 3的代码块，还会继续执行后面case的代码块，直到遇到break或者switch结束，这可能会导致不符合预期的结果 。

循环语句

循环语句是 C++ 编程中实现重复执行一段代码的重要工具，它能够让程序在满足特定条件时不断地执行某一部分代码，大大提高了编程的效率和灵活性。在 C++ 中，主要有三种循环语句：for循环、while循环和do - while循环，它们各自适用于不同的场景，为开发者提供了多样化的选择。

for循环是一种非常常用的循环结构，它特别适合在已知循环次数的情况下使用。其语法结构如下：

for (初始化表达式; 条件表达式; 迭代表达式) {
// 循环体，需要重复执行的代码块
}

在for循环中，首先会执行初始化表达式，用于初始化循环变量，这个操作只在循环开始时执行一次。然后会检查条件表达式的值，如果条件表达式为真（true），则执行循环体中的代码。执行完循环体后，会执行迭代表达式，通常用于更新循环变量的值。接着再次检查条件表达式，如此循环往复，直到条件表达式为假（false）时，循环结束。例如，我们可以使用for循环来打印从 1 到 10 的数字：

for (int i = 1; i <= 10; i++) {
    cout << i << " ";
}
cout << endl;

在这个例子中，int i = 1是初始化表达式，用于初始化循环变量i为 1；i <= 10是条件表达式，只要i小于等于 10，循环就会继续执行；i++是迭代表达式，每次循环结束后，i的值会增加 1。在循环体中，cout << i << " ";语句会将i的值输出到控制台。

while循环则更侧重于根据条件来控制循环的执行，它的语法结构为：

while (条件表达式) {
// 循环体，需要重复执行的代码块
}

在while循环中，每次循环开始时都会检查条件表达式的值，如果条件表达式为真，就会执行循环体中的代码，执行完后再次检查条件表达式，直到条件表达式为假时，循环结束。例如，我们可以使用while循环来计算 1 到 100 的累加和：

int sum = 0, num = 1;
while (num <= 100) {
    sum += num;
    num++;
}
cout << "1到100的累加和为：" << sum << endl;

在这个例子中，num <= 100是条件表达式，只要num小于等于 100，循环就会继续。在循环体中，sum += num;语句将num的值累加到sum中，num++;语句则更新num的值，使其逐渐增大，直到num大于 100 时，循环结束。

do - while循环与while循环类似，但它的特点是无论条件表达式是否为真，循环体至少会执行一次。其语法结构如下：

do {
// 循环体，需要重复执行的代码块
} while (条件表达式);

在do - while循环中，首先会执行一次循环体，然后检查条件表达式的值，如果条件表达式为真，就会继续执行循环体，直到条件表达式为假时，循环结束。例如，我们可以使用do - while循环来实现一个简单的猜数字游戏，让用户不断猜测一个预设的数字：

#include <iostream>
#include <cstdlib
#include <ctime>

int main() {

   srand(static_cast<unsigned int>(time(nullptr)));

   int target = rand() % 100 + 1;

   int guess;

   do {

       cout << "请输入你猜测的数字（1 - 100）：";

       cin >> guess;

       if (guess > target) {

           cout << "你猜的数字太大了" << endl;

       } else if (guess < target) {

           cout << "你猜的数字太小了" << endl;

       }

   } while (guess!= target);

   cout << "恭喜你，猜对了！" << endl;

   return 0;

}

在这个例子中，无论用户第一次输入的数字是否正确，循环体都会先执行一次，让用户输入猜测的数字。然后根据用户输入的数字与预设数字的比较结果，给出相应的提示，并继续循环，直到用户猜对为止。

跳转语句

跳转语句在 C++ 编程中扮演着特殊的角色，它能够改变程序的执行流程，使程序跳转到指定的位置继续执行。常见的跳转语句有break、continue和goto，它们各自有着不同的作用和使用场景，但需要注意的是，goto语句由于可能会使程序的结构变得复杂和难以维护，一般应谨慎使用。

break语句主要用于跳出当前的循环结构（如for、while、do - while循环）或switch语句。当程序执行到break语句时，会立即终止当前所在的循环或switch语句，然后执行循环或switch语句后面的代码。例如，在一个for循环中，我们要查找数组中第一个大于 10 的元素，并输出其位置：

int arr[] = {5, 8, 12, 15, 20};

int size = sizeof(arr) / sizeof(arr[0]);

for (int i = 0; i < size; i++) {

  if (arr[i] > 10) {

       cout << "第一个大于10的元素在位置：" << i << endl;

      break;

   }
}

在这个例子中，当arr[i] > 10条件满足时，执行break语句，跳出for循环，此时程序不会再继续执行for循环中剩余的代码，而是直接执行for循环后面的代码。在switch语句中，break语句也起着类似的作用，用于跳出switch语句，避免执行不必要的case分支。

continue语句则用于跳过当前循环中剩余的代码，直接进入下一次循环。当程序执行到continue语句时，会立即结束本次循环，然后回到循环的条件判断部分，决定是否继续执行下一次循环。例如，在一个for循环中，我们要输出 1 到 10 之间的奇数：

for (int i = 1; i <= 10; i++) {

   if (i % 2 == 0) {

       continue;

   }

   cout << i << " ";

}

cout << endl;

在这个例子中，当i % 2 == 0条件满足时，即i为偶数时，执行continue语句，跳过cout << i << " ";这一行代码，直接进入下一次循环，这样就只会输出 1 到 10 之间的奇数。

goto语句是一种无条件跳转语句，它可以使程序跳转到指定的标签处继续执行。其语法格式为：goto 标签;，其中 “标签” 是一个自定义的标识符，用于标记程序中的某个位置。例如：

int num = 1;

start:

   cout << num << " ";

   num++;

   if (num <= 5) {

       goto start;

   }

在这个例子中，goto start;语句会使程序跳转到start:标签处，继续执行下面的代码，从而实现了一个简单的循环，输出 1 到 5 的数字。然而，过度使用goto语句会使程序的逻辑变得混乱，增加代码的阅读和维护难度，就像在一个复杂的迷宫中随意穿梭，让人难以理清程序的执行路径。因此，在现代编程中，应尽量避免使用goto语句，除非在某些特定的情况下，如在多层嵌套循环中需要快速跳出所有循环时，goto语句可能会是一种较为便捷的选择，但也需要谨慎使用，确保代码的可读性和可维护性。

函数

函数的定义与声明

在 C++ 编程中，函数是一个非常重要的概念，它就像是一个具有特定功能的 “小盒子”，你把一些数据（参数）放进去，它经过一系列的处理后，会返回一个结果（返回值），或者执行一些特定的操作。通过函数，我们可以将复杂的程序分解为一个个独立的、可管理的模块，提高代码的可读性、可维护性和可复用性。

函数的定义一般包含 5 个关键部分：返回值类型、函数名、参数列表、函数体语句和 return 表达式。其基本语法格式如下：

返回值类型 函数名 (参数列表) {

   函数体语句

   return 表达式;

}

下面以一个简单的加法函数为例，来详细说明函数的定义：

int add(int num1, int num2) {

   int sum = num1 + num2;

   return sum;

}

在这个例子中：

int 是返回值类型，表示这个函数执行完毕后会返回一个整数类型的值。

add 是函数名，它是我们调用这个函数时使用的标识符，就像给这个 “小盒子” 取了个名字，方便我们在程序的其他地方找到它。

(int num1, int num2) 是参数列表，这里定义了两个参数，num1 和 num2，它们都是整数类型。这些参数就像是 “小盒子” 的输入口，我们在调用函数时，需要给这些参数传递具体的值，函数会根据这些值进行相应的计算。

{ int sum = num1 + num2; return sum; } 是函数体语句，这是函数实现具体功能的地方。在这个例子中，函数首先将两个参数相加，结果存储在 sum 变量中，然后通过 return 语句返回 sum 的值。

有时候，我们可能需要在使用函数之前先告诉编译器函数的存在和基本信息，这就是函数的声明。函数声明的作用是让编译器知道函数的名字、参数类型和返回值类型，这样在编译阶段，编译器就可以对函数的调用进行语法检查，即使函数的定义在后面才出现也不会报错。函数声明的语法和函数定义类似，但不需要函数体，并且末尾要加上分号，例如：

int add(int num1, int num2);

在实际编程中，如果函数的定义在调用它的函数之前，那么可以不进行单独的声明；但如果函数定义在调用之后，就必须先进行声明。例如：

#include <iostream>

// 函数声明
int max(int num1, int num2);

int main() {

   int a = 10, b = 20;

   int result = max(a, b);

   std::cout << "较大值是: " << result << std::endl;

   return 0;

}

// 函数定义
int max(int num1, int num2) {

   return num1 > num2? num1 : num2;

}

在这个例子中，max 函数的声明在 main 函数之前，这样在 main 函数中调用 max 函数时，编译器就知道 max 函数的参数类型和返回值类型，能够正确地进行编译。如果没有这个声明，编译器在编译到 max(a, b) 时，就会因为不知道 max 函数的相关信息而报错。

函数参数传递

在 C++ 中，函数参数传递主要有两种方式：传值传递和传引用传递，它们在函数调用时对参数的处理方式有着明显的区别，理解这些区别对于编写高效、正确的代码至关重要。

传值传递是一种比较直观的参数传递方式。当函数被调用时，系统会为函数的形参创建一个新的副本，这个副本的值与调用函数时传入的实参值相同。在函数内部对形参的任何修改，都只会影响这个副本，而不会改变原始的实参值。例如：

#include <iostream>

void swap(int num1, int num2) {

   int temp = num1;

   num1 = num2;

   num2 = temp;

   std::cout << "交换后函数内 num1: " << num1 << ", num2: " << num2 << std::endl;

}

int main() {

   int a = 10, b = 20;

   std::cout << "交换前 main 函数内 a: " << a << ", b: " << b << std::endl;

   swap(a, b);

   std::cout << "交换后 main 函数内 a: " << a << ", b: " << b << std::endl;

   return 0;

}

在这个例子中，swap 函数接受两个整数参数 num1 和 num2，在函数内部，通过临时变量 temp 对 num1 和 num2 的值进行了交换。然而，当我们在 main 函数中调用 swap(a, b) 后，会发现 a 和 b 的值并没有发生改变。这是因为 swap 函数中的 num1 和 num2 是 a 和 b 的副本，对副本的修改不会影响到原始的 a 和 b。传值传递的优点是简单易懂，数据安全性较高，因为函数内部无法直接修改原始数据；但缺点是如果传递的是较大的对象，复制副本会消耗较多的时间和内存，影响程序的性能。

传引用传递则不同，当使用传引用传递参数时，函数接收的不是实参的副本，而是实参的引用，也就是实参的别名。这意味着在函数内部对形参的操作，实际上就是对原始实参的操作，会直接影响到原始数据。例如：

#include <iostream>

void swap(int& num1, int& num2) {

   int temp = num1;

   num1 = num2;

   num2 = temp;

   std::cout << "交换后函数内 num1: " << num1 << ", num2: " << num2 << std::endl;

}

int main() {

   int a = 10, b = 20;

   std::cout << "交换前 main 函数内 a: " << a << ", b: " << b << std::endl;

   swap(a, b);

   std::cout << "交换后 main 函数内 a: " << a << ", b: " << b << std::endl;

   return 0;

}

在这个例子中，swap 函数的参数 num1 和 num2 是引用类型，通过 & 符号来表示。当在 main 函数中调用 swap(a, b) 时，num1 和 num2 分别成为了 a 和 b 的引用。在 swap 函数内部对 num1 和 num2 的交换操作，实际上就是对 a 和 b 的交换，所以在 main 函数中可以看到 a 和 b 的值已经被成功交换。传引用传递的优点是效率高，因为不需要复制对象，尤其适用于传递大型对象；但需要注意的是，由于函数可以直接修改原始数据，所以在使用时要谨慎，避免出现意外的修改。

函数返回值

函数返回值是函数执行结果的一种体现，它可以让函数将处理后的数据传递回调用它的地方。在 C++ 中，函数返回值具有特定的类型和返回方式，并且返回值类型必须与函数定义时指定的返回类型一致，这一点非常重要，否则会导致编译错误。

函数返回值的类型就是在函数定义时指定的返回值类型，它可以是 C++ 中的各种基本数据类型，如 int、double、char 等，也可以是自定义的数据类型，如结构体、类等。例如，前面提到的加法函数 add，它的返回值类型是 int，表示函数会返回一个整数：

int add(int num1, int num2) {

   int sum = num1 + num2;

   return sum;

}

在这个例子中，函数通过 return 语句返回了 sum 的值，这个值的类型是 int，与函数定义时的返回值类型一致。

函数返回值的方式主要是通过 return 语句来实现。return 语句有两个作用：一是结束函数的执行，将控制权返回给调用函数的地方；二是返回一个值，这个值就是函数的返回值。return 语句的语法格式为：return 表达式;，其中 “表达式” 的值就是要返回的值，它的类型必须与函数定义的返回值类型兼容。例如：

double calculateAverage(int num1, int num2) {

   double sum = num1 + num2;

   return sum / 2;

}

在这个例子中，calculateAverage 函数的返回值类型是 double，函数通过 return sum / 2; 语句返回了两个整数的平均值，返回值的类型是 double，与函数定义的返回值类型一致。

需要注意的是，如果函数的返回值类型是 void，表示函数没有返回值，此时函数中可以不使用 return 语句，或者使用不带表达式的 return 语句，仅仅用于结束函数的执行。例如：

void printMessage() {

   std::cout << "这是一条没有返回值的函数输出的消息" << std::endl;

   // 这里可以不写 return 语句，函数执行完最后一行代码后会自动结束

   // 或者也可以写 return; 来显式地结束函数

}

在这个例子中，printMessage 函数的返回值类型是 void，它的主要功能是在控制台输出一条消息，不需要返回任何值。

如果函数返回值类型与 return 语句返回的表达式类型不一致，编译器会尝试进行类型转换，但这种转换必须是合法的。如果无法进行合法的类型转换，就会导致编译错误。例如：

int getValue() {

   double num = 3.14;

   return num; // 这里会发生隐式类型转换，将 double 类型的 num 转换为 int 类型

}

在这个例子中，getValue 函数的返回值类型是 int，而 return 语句返回的是 double 类型的 num。编译器会自动将 num 进行隐式类型转换为 int 类型（在这个例子中，会截断小数部分，得到 3），然后返回。但如果返回的表达式类型与函数返回值类型无法进行合法的转换，比如返回一个 string 类型的值给一个 int 类型的返回值，就会报错。

函数重载

函数重载是 C++ 中一个非常实用的特性，它允许在同一个作用域内定义多个同名的函数，但这些函数的参数列表必须不同，包括参数的类型、顺序或数量。通过函数重载，我们可以使用相同的函数名来处理不同类型或不同数量的数据，提高代码的可读性和可维护性。

函数重载的实现条件主要有以下几点：

函数名相同：在同一个作用域内，多个函数的名称必须相同，这样才能体现出 “重载” 的概念，即同一个函数名有多种不同的实现方式。

参数列表不同：这是函数重载的关键条件，参数列表的不同可以体现在以下几个方面：

参数类型不同：例如，有两个函数 add，一个接受两个 int 类型的参数，另一个接受两个 double 类型的参数：

int add(int num1, int num2) {

   return num1 + num2;

}

double add(double num1, double num2) {

   return num1 + num2;

}

在调用 add 函数时，编译器会根据传入参数的类型来决定调用哪个函数。如果传入的是两个 int 类型的值，就会调用第一个 add 函数；如果传入的是两个 double 类型的值，就会调用第二个 add 函数。

参数数量不同：比如，有一个函数 print，可以接受一个 int 类型的参数进行打印，也可以接受两个 int 类型的参数进行打印：

void print(int num) {

   std::cout << "打印一个整数: " << num << std::endl;

}

void print(int num1, int num2) {

   std::cout << "打印两个整数: " << num1 << " 和 " << num2 << std::endl;

}

当调用 print 函数时，如果只传入一个 int 类型的参数，就会调用第一个 print 函数；如果传入两个 int 类型的参数，就会调用第二个 print 函数。

参数顺序不同：例如，有两个函数 compare，一个先接受 int 类型参数，再接受 double 类型参数，另一个则相反：

bool compare(int num1, double num2) {

   return num1 < num2;

}

bool compare(double num1, int num2) {

   return num1 < num2;

}

在调用 compare 函数时，根据传入参数的顺序不同，编译器会调用相应的函数。如果先传入 int 类型参数，再传入 double 类型参数，就会调用第一个 compare 函数；反之，则会调用第二个 compare 函数。

需要注意的是，函数的返回值类型不能作为函数重载的判断条件。也就是说，仅仅返回值类型不同，而参数列表相同的函数，不能构成函数重载。例如：

int add(int num1, int num2) {

   return num1 + num2;

}

double add(int num1, int num2) { // 编译错误，这不是函数重载

   return num1 + num2;

}

在这个例子中，虽然两个 add 函数的返回值类型不同，但参数列表完全相同，这会导致编译错误，因为编译器无法根据函数调用确定应该调用哪个函数。

下面通过一个完整的示例来进一步说明函数重载的使用：

#include <iostream>

// 函数重载示例
void printData(int num) {

   std::cout << "打印整数: " << num << std::endl;

}

void printData(double num) {

   std::cout << "打印双精度浮点数: " << num << std::endl;

}

void printData(const char* str) {

   std::cout << "打印字符串: " << str << std::endl

}

int main() {

   int intValue = 10;

   double doubleValue = 3.14;

   const char* strValue = "Hello, C++";

   printData(intValue);

   printData(doubleValue);

   printData(strValue);

   return 0;

}

在这个示例中，定义了三个名为 printData 的函数，它们分别接受 int、double 和 const char* 类型的参数，构成了函数重载。在 main 函数中，分别调用这三个函数，传入不同类型的参数，编译器会根据参数类型自动选择合适的函数进行调用，从而实现了对不同类型数据的打印功能。

（中篇完）

划重点，C++入门指南（下）