C++学习15、内联函数、递归函数与函数指针

在C++编程的广阔天地中，函数作为代码复用的核心机制，扮演着举足轻重的角色。今天，我们将深入探讨三种特殊的函数类型：内联函数、递归函数和函数指针。

一、内联函数：代码优化的利器

1.内联函数的概念

内联函数（Inline Function）是C++中一种用于优化程序性能的函数类型。当函数体较小且频繁调用时，使用内联函数可以显著提升程序运行效率。内联函数建议编译器在调用函数的地方直接插入或替换为函数体代码，从而消除函数调用的开销。

2.内联函数的声明与定义

在C++中，内联函数通常使用inline关键字进行声明。但请注意，inline只是对编译器的建议，编译器可能会根据优化策略选择是否真正内联。

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

}

3.内联函数的优势与局限

优势：消除函数调用的开销，提升程序性能。
局限：

• 函数体不能过大，否则编译器可能拒绝内联。
• 调试时，由于代码展开，可能难以追踪调用路径。
• 过度使用可能导致二进制文件体积增大。

4.示例与输出

#include <iostream>
 
inline int square(int x) {
    return x * x;
}
 
int main() {
    int num = 5;
    std::cout << "Square of " << num << " is " << square(num) << std::endl;
    // 输出：Square of 5 is 25
    return 0;

}

在上述示例中，square函数被声明为内联函数，编译器在main函数中调用square时，将直接插入x * x的计算代码。

二、递归函数：自我调用的艺术

1.递归函数的概念

递归函数（Recursive Function）是一种在函数体内调用自身的函数。递归函数通常用于解决可以分解为相似子问题的问题，如斐波那契数列、树的遍历等。

2.递归函数的基本结构

递归函数通常包含两个关键部分：

• 递归基准条件：用于结束递归调用的条件。
• 递归步骤：函数调用自身，解决子问题。

3.递归函数的示例与输出

斐波那契数列

#include <iostream>
 
int fibonacci(int n) {
    if (n <= 1) {
        return n; // 递归基准条件
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2); // 递归步骤
    }
}
 
int main() {
    int num = 5;
    std::cout << "Fibonacci number at position " << num << " is " << fibonacci(num) << std::endl;
    // 输出：Fibonacci number at position 5 is 5
    return 0;

}

注意：上述斐波那契数列实现存在效率问题，因为存在大量重复计算。可以使用记忆化或动态规划优化。

树的遍历：以二叉树为例，展示递归遍历（前序、中序、后序）。

#include <iostream>
 
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
 
// 前序遍历
void preorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    std::cout << root->val << " "; // 访问根节点
    preorderTraversal(root->left); // 递归遍历左子树
    preorderTraversal(root->right); // 递归遍历右子树
}
 
int main() {
    // 构建二叉树：1 -> 2 -> 4, 5 -> 3 -> 6, 7
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);
 
    std::cout << "Preorder traversal: ";
    preorderTraversal(root); // 输出：1 2 4 5 3 6 7
    std::cout << std::endl;
 
    // 释放内存（略）
    return 0;

}

4.递归函数的注意事项

• 确保递归基准条件正确，避免无限递归。
• 递归深度不宜过大，以免栈溢出。
• 考虑优化递归算法，如记忆化、动态规划等。

三、函数指针：灵活调用函数

1.函数指针的概念

函数指针（Function Pointer）是指向函数的指针。通过函数指针，可以在运行时动态地选择调用哪个函数，实现函数的灵活调用。

2.函数指针的声明与赋值

函数指针的声明与函数声明类似，但需要在函数类型前加上*符号。赋值时，将函数地址赋给函数指针。

#include <iostream>
 
// 函数声明
void func1() {
    std::cout << "Function 1 called" << std::endl;
}
 
void func2() {
    std::cout << "Function 2 called" << std::endl;
}
 
// 函数指针声明
void (*funcPtr)();
 
int main() {
    // 函数指针赋值
    funcPtr = func1;
    funcPtr(); // 调用func1，输出：Function 1 called
 
    funcPtr = func2;
    funcPtr(); // 调用func2，输出：Function 2 called
 
    return 0;

}

3.函数指针的应用场景

• 实现回调函数（Callback Function）：在事件驱动编程中，当某个事件发生时，调用指定的函数。
• 实现策略模式（Strategy Pattern）：通过函数指针，在运行时选择不同的算法或策略。
• 实现函数表（Function Table）：将函数指针存储在数组中，通过索引选择调用哪个函数。

4.函数指针与函数对象

C++11及以后的标准引入了函数对象（Function Object），包括lambda表达式、std::function和函数对象类。它们提供了比函数指针更灵活、更强大的功能。

• lambda表达式

#include <iostream>
#include <vector>
#include <algorithm>
 
int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
 
    // 使用lambda表达式作为排序函数
    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return a > b; // 降序排序
    });
 
    for (int num : vec) {
        std::cout << num << " "; // 输出：5 4 3 2 1
    }
    std::cout << std::endl;
 
    return 0;

}

• std::function

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>
 
void printSum(int a, int b, std::function<void(int)> func) {
    int sum = a + b;
    func(sum);
}
 
int main() {
    // 使用std::function作为回调函数
    printSum(3, 4, [](int sum) {
        std::cout << "Sum: " << sum << std::endl; // 输出：Sum: 7
    });
 
    return 0;
}