第十三章---C++ 函数、递归、友元函数、函数指针和回调

函数是一组接受输入、执行一些特定计算并生成输出的语句。这个想法是将一些经常或重复完成的任务放在一起组成一个函数，这样我们就可以调用这个函数，而不是一次又一次地为不同的输入编写相同的代码。

简单来说，函数是仅在调用时运行的代码块。

函数：

函数的定义

一个基本的C++函数定义包括以下几个部分：

返回类型：函数执行后返回的结果类型。
函数名：用于标识函数的唯一名称。
参数列表：函数执行时传入的数据，可以没有参数。
函数体：花括号内的代码块，包含执行特定任务的语句。
下面是一个简单的函数定义示例：

// 返回类型是int，函数名为add，有两个int类型的参数
int add(int a, int b) {
    return a + b; // 执行加法操作，并返回结果
}

函数的调用

定义函数后，可以在程序的其他部分调用它。调用函数时，需要提供相应的参数（如果有的话），并可以使用返回值（如果函数有返回类型的话）。

int result = add(5, 3); // 调用add函数，并接收返回值

函数的参数

函数的参数可以是多种类型，包括基本数据类型、复合数据类型、指针、引用等。

值传递（Pass by Value）：默认情况下，函数参数是通过值传递的，这意味着函数内部对参数的修改不会影响原始变量。
引用传递（Pass by Reference）：使用引用传递参数时，函数内部对参数的修改会影响原始变量。
指针传递（Pass by Pointer）：与引用类似，通过指针传递可以允许函数修改调用者的数据。

函数的返回类型

函数的返回类型可以是任何有效的C++数据类型，包括基本类型、复合类型、指针、引用等。如果函数不需要返回值，可以指定返回类型为void。

特殊函数

main()函数：C++程序的入口点，每个程序都必须有一个main()函数。
构造函数和析构函数：用于对象的创建和销毁。
成员函数和静态成员函数：属于类的函数。

函数重载（Function Overloading）

C++允许定义多个同名函数，只要它们的参数列表（参数类型、数量或顺序）不同。这被称为函数重载。

int add(int a, int b);       // 第一个add函数
double add(double a, double b); // 第二个add函数，参数类型不同

默认参数

在C++中，可以为函数参数提供默认值。如果调用函数时没有为这些参数提供值，则使用默认值。

void print(int n, int base = 10) {
    // 如果base没有提供，则默认为10
}

内联函数（Inline Functions）

内联函数是建议编译器在调用点展开函数体的函数，以减少函数调用的开销。这通常用于小型、频繁调用的函数。

inline int max(int a, int b) {
    return (a > b) ? a : b;
}

函数模板

C++支持函数模板，允许编写与类型无关的代码。模板定义以关键字template开始，后跟一个或多个模板参数。

template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

通过上述内容，我们可以看到C++中的函数非常灵活，它们是构建模块化、可维护和高效程序的基础。

递归：

递归是一种编程技巧，它允许函数调用自身。在C++中，实现递归的基本步骤如下：

递归基（Base Case）：递归必须有一个或多个基例，这是递归终止的条件。没有基例，递归将会无限进行下去，最终导致栈溢出错误。
递归步骤（Recursive Step）：在函数体内部，至少要有一个递归调用，它将问题分解为更小的相同问题。
递归调用：在递归步骤中，函数调用自身，但通常是在更小的输入或更接近基例的条件下。
下面通过一个经典例子——计算斐波那契数列（Fibonacci sequence）的第n项——来展示如何实现递归：

#include <iostream>
// 函数声明
int fibonacci(int n);
int main() {
    int n;
    std::cout << "Enter the Fibonacci sequence number to calculate: ";
    std::cin >> n;
    
    // 输出斐波那契数列的第n项
    std::cout << "Fibonacci number is: " << fibonacci(n) << std::endl;
    return 0;
}
// 斐波那契数列的递归实现
int fibonacci(int n) {
    // 递归基：第0项是0，第1项是1
    if (n == 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    }
    
    // 递归步骤：第n项是第n-1项和第n-2项之和
    return fibonacci(n - 1) + fibonacci(n - 2);
}

在这个例子中：

递归基是n == 0和n == 1，对应斐波那契数列的前两个数。
递归步骤是return fibonacci(n - 1) + fibonacci(n - 2);，这里函数fibonacci调用自身，但是每次调用时的参数n都更小，逐渐接近基例。
递归的优势在于它可以简化某些问题的解决方案，使其更易于理解和实现。

然而，递归也有缺点，例如：

效率问题：如上面的斐波那契数列递归实现，会有大量的重复计算，效率较低。
栈空间：每次递归调用都会在调用栈上占用空间，如果递归深度太大，可能会导致栈溢出。
为了提高效率，通常会使用记忆化（Memoization）或动态规划（Dynamic Programming）等技术来优化递归算法。

友元函数（friend function）：

在C++中，友元函数（friend function）是一种特殊类型的函数，它可以访问类的私有（private）和受保护的（protected）成员，即使这个函数不是类的成员函数。通常，友元函数用于操作类的私有数据成员，而无需将该操作暴露为类的公共接口。
要声明一个友元函数，你需要在类定义中使用 friend 关键字。以下是友元函数的几个要点和使用示例：

友元函数要点：

不是类的成员：友元函数定义在类的外部，不受类的作用域限制。
可以访问类的私有和受保护成员：友元函数可以访问类的所有成员，包括私有和受保护成员。
不需要通过对象调用：友元函数不通过对象来调用，它可以直接调用，就像普通函数一样。
友元关系是单向的：如果类A声明了类B的函数为友元，这并不意味着类B的函数也能访问类A的私有成员。
友元关系不可传递：如果函数f是类A的友元，并且类A是类B的友元，这并不意味着函数f是类B的友元。

示例：

以下是一个使用友元函数的示例，其中包含一个名为 Box 的类，该类有一个友元函数 printBoxSize，用于打印 Box 对象的尺寸。

#include <iostream>
class Box {
private:
    double width;
public:
    Box(double w) : width(w) {}
    // 声明printBoxSize为友元函数
    friend void printBoxSize(Box box);
};
// 定义友元函数
void printBoxSize(Box box) {
    std::cout << "Box width: " << box.width << std::endl;
}
int main() {
    Box box(10.0);
    // 直接调用友元函数，不需要通过对象
    printBoxSize(box);
    return 0;
}

在这个例子中，printBoxSize 函数能够访问 Box 类的私有成员 width，尽管它不是 Box 类的成员函数。这允许 printBoxSize 函数直接打印 Box 对象的宽度，而无需 Box 类提供公共接口来访问其私有成员。

在C++中，函数指针和回调是两个紧密相关的概念。以下是它们的详细解释：

函数指针和回调

函数指针

函数指针是一个指向函数的指针，就像普通指针指向变量一样。函数指针可以用于调用函数，也可以作为参数传递给其他函数，或者在运行时动态地选择要调用的函数。

定义函数指针

函数指针的定义方式如下：

返回类型 (*指针变量名)(参数类型1, 参数类型2, ...);

例如，如果你有一个返回int并且接受两个int参数的函数，可以这样定义函数指针：

int (*funcPtr)(int, int);

使用函数指针

假设有一个函数：

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

你可以将add函数的地址赋值给funcPtr：

funcPtr = &add;

或者更简单地：

funcPtr = add;

然后，你可以通过函数指针调用该函数：

int result = funcPtr(3, 4); // 调用 add(3, 4)

回调函数

回调函数是一种通过函数指针调用的函数。在C++中，回调函数通常用于在特定的事件或条件发生时执行代码。回调可以使程序设计更加模块化和灵活。

使用回调

以下是如何使用回调函数的示例：

#include <iostream>
// 回调函数类型
typedef void (*Callback)(int);
// 一个接受回调函数作为参数的函数
void performOperation(int a, int b, Callback callback) {
    int result = a + b;
    callback(result); // 调用回调函数
}
// 实现回调函数
void printResult(int result) {
    std::cout << "The result is: " << result << std::endl;
}
int main() {
    // 调用 performOperation 并传递 printResult 作为回调
    performOperation(5, 3, printResult);
    return 0;
}

在上面的例子中，performOperation函数接受两个整数和一个Callback类型的函数指针。printResult函数符合Callback类型，因为它接受一个整数并返回void。当performOperation计算结果后，它通过回调函数printResult打印结果。