目录

循环

循环类型

循环控制语句

无限循环

判断

判断语句

? : 运算符

函数

函数定义

函数声明

函数参数

参数的默认值

函数重载

函数模板

内联函数inline

调用函数

Lambda 函数与表达式

---

循环

循环类型

在计算机科学中，循环是一种重复执行一段代码直到满足某个条件的控制结构。通常，循环由一个条件表达式和一个要重复执行的代码块组成。当条件表达式为true时，代码块被执行；当条件表达式为false时，循环终止。

循环的基本类型有三种：while循环、do-while循环和for循环。

• while循环会在每次循环前先检查条件表达式的值。只有当条件表达式的值为true时，代码块才会被执行。
• do-while循环则是在执行代码块后再检查条件表达式的值。这意味着代码块至少会被执行一次，即使条件表达式一开始就为false。
• for循环能够提供更加紧凑的语法，它通常用于已知要重复的次数的情况下。for循环由一个初始化语句、一个条件表达式和一个更新语句组成，它们定义了循环的起始条件、执行条件和每次循环后的操作。

实例

#include <iostream>
using namespace std;int main() {int n = 10;// while循环示例cout << "while循环示例：" << endl;while (n > 0) {cout << "当前n的值为：" << n << endl;n--;}n = 10; // 重置n的值// do-while循环示例cout << "\ndo-while循环示例：" << endl;do {cout << "当前n的值为：" << n << endl;n--;} while (n > 0);n = 10; // 重置n的值// for循环示例cout << "\nfor循环示例：" << endl;for (int i = 0; i < n; i++) {cout << "当前i的值为：" << i << endl;}return 0;
}

这个示例程序演示了三种不同类型的循环：while循环、do-while循环和for循环。程序开始时，我们初始化了一个变量 n 的值为10。

首先是while循环，它通过判断 n 是否大于0来决定是否继续执行循环体内的代码块。在每次迭代中，我们打印出 n 的当前值，并将 n 自减1，直到 n 不再大于0为止。

接下来是 do-while 循环。这种循环先执行一次循环体内的代码块，然后再判断条件是否满足。在这个示例中，我们使用了与上面相同的代码体，并在每次迭代之前将 n 的值递减1。

最后是 for 循环，在其括号内，我们首先初始化一个循环变量 i 的值为0，然后设置循环继续的条件为 i 小于 n。在每次迭代中，我们打印出 i 的当前值，并将 i 自增1，直到 i 不再小于 n。

循环控制语句

循环控制语句是用于在循环过程中改变循环行为的特殊语句。在C++中，有三种常见的循环控制语句：break、continue和goto。

1、break: 当break语句出现在循环体内时，它会终止当前所在的循环，并将控制转移到循环后的下一条语句。使用break可以提前跳出循环，而不必等到循环条件变为false。例如：

for (int i = 0; i < 10; i++) {if (i == 5) {break; // 当i等于5时跳出循环}cout << i << endl;
}

2、continue: continue语句用于跳过当前迭代的剩余代码，并开始下一次迭代。当continue语句执行时，程序将立即跳到循环的下一个迭代。例如：

for (int i = 0; i < 10; i++) {if (i == 5) {continue; // 当i等于5时跳过本次循环剩余代码，开始下一次迭代}cout << i << endl;
}

3、goto: goto语句允许无条件地转移到程序中的标签位置。尽管goto可以使控制流难以理解和维护，但在某些情况下它可能是有用的。通常情况下，最好避免使用goto语句。例如：

for (int i = 0; i < 10; i++) {if (i == 5) {goto end; // 当i等于5时跳转到标签end处}cout << i << endl;
}end:
cout << "循环结束" << endl;

无限循环

无限循环指的是在程序中使用一个循环结构，循环条件始终为真，从而使循环永远不会退出。在C++中实现无限循环的最常用方式是使用while或for循环，并将循环条件设置为true。

以下是一个使用while循环实现无限循环的示例：

while (true) {// 循环体
}

以下是一个使用for循环实现无限循环的示例：

for (;;) {// 循环体
}

需要注意的是，在编写无限循环时，应确保程序能够在某些条件下退出循环，否则程序将一直运行下去，可能导致系统崩溃或其他问题。例如，在编写服务器程序时，可以使用无限循环来监听客户端请求，但当接收到特定的信号时，程序应该退出循环并关闭服务器。

实例1

#include <iostream>int main() {while (true) { // 无限循环std::cout << "这是一个无限循环示例。" << std::endl;char choice;std::cout << "是否继续循环？(y/n): ";std::cin >> choice;if (choice == 'n' || choice == 'N') {break; // 当用户选择"n"或"N"时跳出循环}}std::cout << "循环结束。" << std::endl;return 0;
}

在上面的代码中，使用while (true)创建了一个无限循环。在循环体中，输出一条消息并提示用户是否要继续循环。根据用户输入的选择，如果输入是"n"或"N"，则使用break语句跳出循环；否则，继续执行下一次循环。

实例2

由于构成循环的三个表达式中任何一个都不是必需的，可以将某些条件表达式留空来构成一个无限循环。

#include <iostream>
using namespace std;int main()
{for (; ; ){printf("This loop will run forever.\n");}return 0;
}

当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，C++ 程序员偏向于使用 for(;;) 结构来表示一个无限循环。

注意：可以按 Ctrl + C 键终止一个无限循环。

判断

判断语句

判断语句（条件语句）用于根据给定的条件来选择是否执行特定的代码块。在C++中，最常见的判断语句是if语句和switch语句。

1、if语句：if语句根据给定的条件决定是否执行某个代码块或语句。语法如下：

if (condition) {// 在条件为真时执行的代码块
} else {// 在条件为假时执行的代码块（可选）
}

condition是一个布尔表达式，如果它的值为真，则执行第一个代码块；如果为假，则执行else后面的代码块（可选）。例如：

int x = 5;if (x > 10) {std::cout << "x大于10" << std::endl;
} else {std::cout << "x不大于10" << std::endl;
}

2、switch语句：switch语句根据表达式的值在多个选项中进行选择，并执行与选项相关联的代码块。它提供了一种更清晰的方式来处理多个条件的情况。语法如下：

switch (expression) {case value1:// 与value1相关联的代码块break;case value2:// 与value2相关联的代码块break;// 可以有更多的case语句default:// 如果expression与所有case值都不匹配时执行的代码块（可选）
}

expression是一个表达式，value1、value2等是可能的值。当expression与某个case的值相等时，将执行与该case相关联的代码块。如果没有任何一个case匹配，可以使用default来执行默认代码块（可选）。每个case后面都必须使用break语句终止代码块的执行，以防止进入下一个case。例如：

int day = 3;switch (day) {case 1:std::cout << "周一" << std::endl;break;case 2:std::cout << "周二" << std::endl;break;case 3:std::cout << "周三" << std::endl;break;default:std::cout << "其他" << std::endl;break;
}

? : 运算符

C++中的?:运算符是三元条件运算符，也称为“三目运算符”。它提供了一种简洁的方式来在两个选项之间进行选择。它的语法如下：

condition ? value1 : value2

condition是一个布尔表达式。如果它的值为真，则返回value1；否则返回value2。可以将结果赋给变量或直接使用它。例如：

int x = 5;
std::string message = (x > 10) ? "x大于10" : "x不大于10";
std::cout << message << std::endl;

在上面的示例中，使用三元条件运算符将一个字符串赋值给message变量，该字符串取决于x是否大于10。如果x大于10，则返回第一个值；否则返回第二个值。最终输出的结果会根据x的值而不同。

需要注意的是，虽然?:运算符可以简化某些条件控制情况的代码，但过度使用可能会导致代码难以理解和维护。应该适当地使用它，以保持代码的清晰度和可读性。

函数

函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。

函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。

C++ 标准库提供了大量的程序可以调用的内置函数。例如，函数 strcat() 用来连接两个字符串，函数 memcpy() 用来复制内存到另一个位置。函数还有很多叫法，比如方法、子例程或程序，等等。

函数定义

函数定义指定了函数的实际代码。它描述了函数应该做什么，以及如何实现该功能。函数定义通常在源文件中定义。

函数的基本语法如下：

return_type function_name(parameter_list) {// 函数的代码块return value;
}

其中：

• return_type是函数返回值的数据类型，可以是任何有效的C++数据类型或void（如果函数没有返回值）。
• function_name是函数的名称，可以自行命名，但要符合标识符的命名规则。
• parameter_list是函数的参数列表，在函数调用时将传递给函数的变量。如果函数没有参数，则可以留空或使用void。
• 函数代码块中包含的语句是函数的主体。在这里，我们可以执行所需的操作，并使用return语句返回值（如果有的话）。

下面是一个简单函数的示例：

int add(int a, int b) {int sum = a + b;return sum;
}

在这个例子中，函数名为“add”，它包含两个整数参数“a”和“b”。函数的主体定义了一个变量“sum”，并将结果返回给调用者。可以通过调用该函数，并传递所需的参数来使用该函数：

int x = 5;
int y = 10;
int result = add(x, y);

在上面的示例中，我们将变量“x”和“y”的值传递给“add”函数，并将计算结果存储在“result”变量中。

需要注意的是，在C++中，函数可以具有默认参数、函数重载、指针参数和引用参数等特性，这些特性使得函数更加灵活和强大。同时，函数还可以返回数组、结构体和类等复杂数据类型，以满足各种编程需求。

函数声明

函数声明是指在使用函数之前提前声明函数的存在和函数的签名（名称、参数列表和返回类型）。函数声明的目的是为了让编译器知道函数的存在，并且可以在调用函数时进行类型检查。

函数声明通常位于头文件中，并且使用与函数定义相同的语法，但在函数体的位置使用分号结束，而不是具体的函数实现。

下面是函数声明的一般语法：

return_type function_name(parameter_list);

其中的各个部分与函数定义的语法相同。

例如，我们有一个函数定义如下：

int add(int a, int b) {return a + b;
}

对应的函数声明可以写作：

int add(int a, int b);

在头文件中声明函数后，可以在其他源文件中包含该头文件并使用该函数，而无需知道其具体实现细节。

需要注意的是，如果函数定义位于同一个源文件中，并且出现在函数调用之后，则可以省略函数声明。但是，如果函数定义在其他源文件中，或者函数调用出现在函数定义之前的位置，就需要先进行函数声明。

函数声明在大型项目中非常重要，它可以帮助确保函数在程序中正确地使用和调用。此外，函数声明还有助于提高代码的可读性和可维护性，因为它清晰地表明了函数的接口和功能。

函数参数

如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。当调用函数时，有三种向函数传递参数的方式：

• 传值调用（Call by Value）：将实参的值复制给形参，在函数内部操作形参，不影响实参的值。
• 指针调用（Call by Pointer）：将实参的地址作为形参传递给函数，在函数内部通过指针访问和修改实参的值。
• 引用调用（Call by Reference）：将实参的引用作为形参传递给函数，在函数内部直接访问和修改实参的值。

默认情况下，C++使用传值调用来传递参数，这意味着在函数内部，对形参的任何修改都不会影响原始的实参值。但是，如果我们希望在函数内部修改实参值，则可以使用指针调用或引用调用。这两种方式都允许函数直接对实参进行修改。

需要注意的是，指针调用和引用调用虽然可以修改实参值，但也需要注意潜在的问题。例如，如果不小心修改了指针或引用本身的值，则可能会导致程序出现错误或崩溃。因此，在使用这些调用方式时，需要格外小心。

另外，C++还支持默认参数，在函数声明时为参数设置默认值。这可以让函数更加灵活，避免在调用函数时重复输入相同的参数值。

参数的默认值

在C++中，可以为函数的参数设置默认值，这样在调用函数时可以选择不提供对应的参数值，而是使用默认值。这种设置默认值的参数称为默认参数（Default Parameters）。

在函数声明或定义中，可以通过在参数列表中为参数指定一个默认值来设置默认参数。例如：

void printMessage(const std::string& message = "Hello, World!");

在上面的例子中，函数printMessage有一个类型为std::string的参数message，并将其默认值设置为"Hello, World!"。这意味着如果在调用该函数时没有提供参数值，将使用默认值。

当函数有多个参数时，可以为其中的某些参数设置默认值。但是，默认参数必须从右向左连续设置。也就是说，在设置了默认参数后，右侧的所有参数都必须拥有默认值。

void printNumbers(int a, int b = 0, int c = 0);

在上面的例子中，函数printNumbers有三个参数，其中b和c都有默认值，而a没有默认值。这样可以实现在调用函数时灵活地选择是否提供b和c的值。

需要注意的是，一旦为参数设置了默认值，那么这个参数可以被省略，但是如果提供了对应的参数值，它将覆盖默认值。

printMessage(); // 使用默认值"Hello, World!"
printMessage("Hello, C++!"); // 使用指定的参数值"Hello, C++!"

通过设置默认参数，我们可以在函数定义时为参数提供一个常用的默认值，以便在调用函数时减少重复输入，并提供更灵活的使用方式。 

实例

#include <iostream>// 带有默认参数的函数，计算两个数的乘积，默认为2
int multiply(int a, int b = 2) {return a * b;
}int main() {int x = 5;int y = 3;// 调用函数时只提供一个参数值，将使用默认值作为第二个参数int result1 = multiply(x); // 等同于 multiply(x, 2)std::cout << "结果1：" << result1 << std::endl; // 输出：结果1：10// 调用函数时提供两个参数值，将覆盖默认值int result2 = multiply(x, y);std::cout << "结果2：" << result2 << std::endl; // 输出：结果2：15return 0;
}

在上面的代码中，multiply函数有两个参数 a 和 b，其中 b 的默认值被设置为2。在 main 函数中，我们首先调用 multiply 函数并只提供一个参数 x，这样将使用默认值2作为第二个参数的值，然后计算乘积并将结果存储在 result1 中。接着，我们再次调用 multiply 函数，但这次提供了两个参数 x 和 y，这将覆盖默认值，并计算乘积并将结果存储在 result2 中。

通过设置默认参数，我们可以在函数定义时为参数提供一个常用的默认值，以便在调用函数时减少重复输入，并提供更灵活的使用方式。

函数重载

C++中的函数重载是指在同一个作用域内，可以定义多个（两个或以上）具有相同名称但参数列表不同的函数。通过函数重载，可以根据不同的参数类型或参数个数，调用合适的函数来完成相似但略有不同的操作。

函数重载的特点如下：

1. 函数名称相同，但参数列表不同。参数列表包括参数的类型、参数的个数以及参数的顺序。

2. 返回类型不是函数重载的条件，因为函数的返回类型不会影响函数的重载。

3. 函数重载只对同一作用域内的函数起作用，不同作用域内的函数即使名称和参数列表相同，也不构成函数重载。

函数重载的示例代码如下：

#include <iostream>// 重载函数 add，用于计算两个整数之和
int add(int a, int b) {return a + b;
}// 重载函数 add，用于计算三个整数之和
int add(int a, int b, int c) {return a + b + c;
}// 重载函数 add，用于计算两个浮点数之和
float add(float a, float b) {return a + b;
}int main() {int result1 = add(1, 2);std::cout << "result1: " << result1 << std::endl;int result2 = add(1, 2, 3);std::cout << "result2: " << result2 << std::endl;float result3 = add(1.5f, 2.5f);std::cout << "result3: " << result3 << std::endl;return 0;
}

在上述示例中，我们定义了三个名为add的函数，并对其参数列表进行了不同的定义。第一个add函数用于计算两个整数之和，第二个add函数用于计算三个整数之和，第三个add函数用于计算两个浮点数之和。通过函数重载，我们可以根据传入的参数类型和个数，调用合适的add函数来进行计算。

需要注意的是，函数重载不仅仅限于参数类型和个数的不同，还可以包括参数的顺序不同或者参数的常量修饰符（const）不同等情况。编译器会根据调用时提供的参数类型和个数，自动匹配最合适的函数进行调用。

总结起来，C++中的函数重载允许在同一作用域内定义多个具有相同名称但参数列表不同的函数。通过函数重载，可以根据不同的参数类型或参数个数，调用合适的函数来完成相似但略有不同的操作。这是C++语言中提高代码灵活性和可读性的重要特性之一。

函数模板

函数模板是C++中一种通用的编程技术，它允许编写可以适用于多种数据类型的函数。通过使用函数模板，可以避免为每种数据类型都编写重复的代码，减少了代码冗余并提高了代码的可维护性和可复用性。

函数模板的语法形式如下：

template <typename T>
返回类型 函数名(参数列表)
{// 函数实现
}

在上述语法中，template关键字表示定义一个模板，typename T或class T表示通用的类型参数，可以根据需要使用不同的类型参数名。在函数名后面的括号里，可以定义函数的参数列表。在函数体内部，可以使用类型参数T来定义变量、进行计算等操作。

使用函数模板时，可以在调用函数时显式指定所需的具体数据类型，也可以让编译器根据传入的参数自动推断出数据类型。

以下是一个使用函数模板的示例，该函数用于比较两个值的大小并返回较大的值：

#include <iostream>template <typename T>
T Max(T a, T b)
{return (a > b) ? a : b;
}int main()
{int x = 5;int y = 10;std::cout << Max(x, y) << std::endl; // 输出10double d1 = 3.14;double d2 = 2.71;std::cout << Max(d1, d2) << std::endl; // 输出3.14return 0;
}

在上述示例中，Max函数是一个函数模板，可以接受任意类型的参数。在main函数中，通过调用Max函数并传入不同类型的参数，可以得到不同类型的返回值。

需要注意的是，函数模板的代码并不会被编译器直接翻译成机器码，而是在实际使用时根据具体的数据类型进行实例化生成对应的函数。这就意味着函数模板的代码会被复制多次，每次针对具体的类型进行处理。

通过使用函数模板，可以提高代码的灵活性和可复用性，并减少重复的代码编写工作。它在STL（标准模板库）等许多C++库中广泛应用，使得C++成为一门强大的通用编程语言。

内联函数inline

内联函数是C++中的一种函数定义方式，它用于向编译器提供一个提示，希望将函数的代码插入到调用处，而不是进行常规的函数调用。

在代码中，使用关键字inline来声明函数为内联函数。例如，下面是一个简单的内联函数示例：

#include <iostream>// 内联函数定义
inline int Max(int a, int b)
{return (a > b) ? a : b;
}int main()
{int x = 5;int y = 10;std::cout << Max(x, y) << std::endl; // 内联函数调用，输出10return 0;
}

在上述代码中，我们使用inline关键字来声明Max函数为内联函数。当在main函数中调用Max(x, y)时，编译器会尝试将内联函数的代码直接插入调用处。

内联函数的使用可以提高程序的执行效率，因为避免了函数调用的开销。然而，内联函数的使用也受到一些限制，例如函数体较大或递归调用的函数通常不适合作为内联函数。此外，并非所有的编译器都会按照inline关键字的提示进行内联展开，具体的内联行为还取决于编译器的实现策略。

总之，通过使用inline关键字可以将函数定义为内联函数，提供给编译器一个优化提示，以便将函数的代码插入到调用处，从而提高程序的执行效率。

调用函数

以下是一个C++函数综合示例代码，其中包含了函数的定义、声明、重载和引用参数等特性

#include <iostream>
using namespace std;// 声明函数原型
int add(int x, int y); // 加法函数
double add(double x, double y); // 重载的加法函数，用于处理浮点数
void swap(int& x, int& y); // 交换函数，使用引用参数来修改变量值int main() {// 调用加法函数int a = 5, b = 10;int sum = add(a, b);cout << "Sum = " << sum << endl;double c = 3.14, d = 2.71;double sum2 = add(c, d);cout << "Sum2 = " << sum2 << endl;// 调用交换函数int x = 100, y = 200;cout << "Before swap: x = " << x << ", y = " << y << endl;swap(x, y);cout << "After swap: x = " << x << ", y = " << y << endl;return 0;
}// 定义加法函数
int add(int x, int y) {return x + y;
}// 重载的加法函数，用于处理浮点数
double add(double x, double y) {return x + y;
}// 定义交换函数
void swap(int& x, int& y) {int temp = x;x = y;y = temp;
}

在上面的示例代码中，我们定义了三个函数：

• add(int x, int y)：加法函数，用于计算两个整数的和。
• add(double x, double y)：重载的加法函数，用于计算两个浮点数的和。
• swap(int& x, int& y)：交换函数，用于交换两个整数变量的值。

在主函数中，我们分别使用这些函数来进行加法运算和变量交换操作。需要注意的是，我们对交换函数使用了引用参数，这允许我们通过函数修改变量值而无需使用指针。

通过这个示例代码，我们可以看到C++函数的多种特性，包括函数声明、函数重载和引用参数等。这些特性使得函数更加灵活和强大，可以满足各种编程需求。

Lambda 函数与表达式

Lambda函数是C++11引入的一种匿名函数形式，它允许我们在需要函数对象的地方直接定义一个函数，而无需显式地定义一个命名函数。Lambda函数常用于简化代码、提高可读性以及在需要函数对象的场景中使用。

Lambda函数的基本语法如下：

[capture list] (parameter list) -> return type { function body }

其中，capture list 是用于捕获变量的列表，用来定义Lambda函数所依赖的外部变量；parameter list 是函数参数列表，类似于普通函数；return type 是函数返回类型，可以省略，编译器会自动推断；function body 是函数体，包含了实际的代码逻辑。

下面是一个示例代码，演示了Lambda函数的使用：

#include <iostream>int main() {int x = 5;// Lambda函数示例auto square = [x](int y) -> int {return x * y;};int result = square(3); // 调用Lambda函数std::cout << "结果：" << result << std::endl; // 输出：结果：15return 0;
}

在上面的代码中，我们定义了一个Lambda函数 square，它接受一个整数参数 y，并返回 x * y 的结果。Lambda函数通过 [x] 的方式捕获了外部变量 x，使得在Lambda函数体内可以直接使用外部变量。然后，我们调用Lambda函数 square，传入参数3，并将结果存储在 result 中。最后，输出结果为15。

Lambda函数的优点之一是可以直接在需要函数对象的地方定义和使用它们，这样可以避免创建额外的命名函数，使代码更加简洁和可读。此外，Lambda函数还可以灵活地捕获外部变量，提供了一种方便的方式来共享上下文信息。