跳到主要内容

C++ 函数指针

函数指针是 C++中一个强大而灵活的特性，它允许我们像使用普通变量一样使用函数。通过函数指针，我们可以在程序运行时动态选择要调用的函数，这为程序设计提供了极大的灵活性。

什么是函数指针？​

函数指针，顾名思义，是指向函数的指针。就像普通指针指向内存中的数据一样，函数指针指向内存中的代码（函数）。

定义

函数指针是一种存储函数地址的变量，通过这个指针，我们可以间接地调用该函数。

函数指针的声明和定义​

声明函数指针的语法看起来可能有点复杂，但理解了基本结构后就会变得清晰：

cpp
返回类型 (*指针名称)(参数类型列表);

让我们通过一个简单的例子来理解：

cpp
// 声明一个函数指针，它指向一个接收两个int参数并返回int的函数
int (*pFunc)(int, int);

这里的pFunc是一个函数指针，它可以指向任何接收两个int参数并返回int类型值的函数。

给函数指针赋值​

要使用函数指针，我们首先需要将它指向一个具体的函数：

cpp
#include <iostream>
using namespace std;

// 定义两个函数，它们具有相同的签名
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int main() {
    // 声明函数指针
    int (*operation)(int, int);
    
    // 将函数指针指向add函数
    operation = add;
    
    // 通过函数指针调用add函数
    cout << "3 + 5 = " << operation(3, 5) << endl;
    
    // 将函数指针指向subtract函数
    operation = subtract;
    
    // 通过函数指针调用subtract函数
    cout << "3 - 5 = " << operation(3, 5) << endl;
    
    return 0;
}

输出：

3 + 5 = 8
3 - 5 = -2

在上面的例子中，我们首先声明了一个函数指针operation，然后将它指向add函数，通过函数指针调用add函数。接着，我们将同一个函数指针指向subtract函数，再通过它调用subtract函数。

函数指针作为函数参数​

函数指针最强大的用途之一是作为函数的参数，这种技术称为"回调"（callback）：

cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 自定义比较函数
bool ascending(int a, int b) {
    return a < b;
}

bool descending(int a, int b) {
    return a > b;
}

// 使用函数指针作为参数的排序函数
void customSort(vector<int>& arr, bool (*compareFunc)(int, int)) {
    sort(arr.begin(), arr.end(), compareFunc);
}

int main() {
    vector<int> numbers = {5, 2, 8, 1, 9};
    
    // 使用升序排序
    customSort(numbers, ascending);
    cout << "升序排序: ";
    for (int num : numbers) {
        cout << num << " ";
    }
    cout << endl;
    
    // 使用降序排序
    customSort(numbers, descending);
    cout << "降序排序: ";
    for (int num : numbers) {
        cout << num << " ";
    }
    cout << endl;
    
    return 0;
}

输出：

升序排序: 1 2 5 8 9 
降序排序: 9 8 5 2 1

在这个例子中，customSort函数接受一个函数指针作为参数，这使得排序行为可以被定制化。

函数指针数组​

我们也可以创建函数指针的数组，这在实现类似"命令模式"的设计模式时非常有用：

cpp
#include <iostream>
using namespace std;

// 定义四个具有相同签名的函数
double add(double a, double b) { return a + b; }
double subtract(double a, double b) { return a - b; }
double multiply(double a, double b) { return a * b; }
double divide(double a, double b) { return (b != 0) ? a / b : 0; }

int main() {
    // 创建函数指针数组
    double (*operations[4])(double, double) = {add, subtract, multiply, divide};
    char ops[4] = {'+', '-', '*', '/'};
    
    double a = 10.0, b = 5.0;
    
    // 通过数组索引调用不同的函数
    for (int i = 0; i < 4; ++i) {
        cout << a << " " << ops[i] << " " << b << " = " << operations[i](a, b) << endl;
    }
    
    return 0;
}

输出：

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
10 / 5 = 2

typedef 和 using 别名简化函数指针​

函数指针的语法可能比较复杂，我们可以使用typedef或C++11引入的using来简化：

cpp
// 使用typedef
typedef int (*MathFunc)(int, int);

// 使用using (C++11及以上)
using MathFunc = int (*)(int, int);

// 使用方法
MathFunc operation = add;

实际应用案例：事件处理系统​

函数指针在实际开发中有很多应用，比如可以用来实现简单的事件处理系统：

cpp
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;

// 事件处理函数的类型
typedef void (*EventHandler)();

// 简单的事件处理系统
class EventSystem {
private:
    map<string, vector<EventHandler>> eventHandlers;
    
public:
    // 注册事件处理函数
    void registerHandler(const string& eventName, EventHandler handler) {
        eventHandlers[eventName].push_back(handler);
    }
    
    // 触发事件
    void triggerEvent(const string& eventName) {
        if (eventHandlers.find(eventName) != eventHandlers.end()) {
            for (auto handler : eventHandlers[eventName]) {
                handler();
            }
        }
    }
};

// 演示用的事件处理函数
void onButtonClick() {
    cout << "按钮被点击了！" << endl;
}

void onWindowClose() {
    cout << "窗口正在关闭..." << endl;
}

int main() {
    EventSystem events;
    
    // 注册事件处理函数
    events.registerHandler("buttonClick", onButtonClick);
    events.registerHandler("windowClose", onWindowClose);
    
    // 触发事件
    cout << "模拟用户点击按钮：" << endl;
    events.triggerEvent("buttonClick");
    
    cout << "模拟关闭窗口：" << endl;
    events.triggerEvent("windowClose");
    
    return 0;
}

输出：

模拟用户点击按钮：
按钮被点击了！
模拟关闭窗口：
窗口正在关闭...

在这个例子中，我们实现了一个简单的事件处理系统，可以注册和触发事件。这种设计在GUI编程、游戏开发等领域非常常见。

C++ 11 中的 std::function​

在现代 C++中，我们可以使用标准库中的std::function类型来代替原始的函数指针，它更加灵活：

cpp
#include <iostream>
#include <functional>
using namespace std;

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

int main() {
    // 使用std::function代替函数指针
    function<int(int, int)> operation = add;
    
    cout << "3 + 5 = " << operation(3, 5) << endl;
    
    // std::function也可以存储lambda表达式
    operation = [](int a, int b) { return a * b; };
    cout << "3 * 5 = " << operation(3, 5) << endl;
    
    return 0;
}

输出：

3 + 5 = 8
3 * 5 = 15

std::function比原始函数指针更强大，因为它可以存储任何可调用对象，包括函数、方法、函数对象和lambda表达式。

成员函数指针​

成员函数指针与普通函数指针有所不同，因为它们还需要关联一个类的实例：

cpp
#include <iostream>
using namespace std;

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
    
    int subtract(int a, int b) {
        return a - b;
    }
};

int main() {
    // 声明一个指向Calculator类的成员函数的指针
    int (Calculator::*operation)(int, int) = &Calculator::add;
    
    // 创建类的实例
    Calculator calc;
    
    // 通过成员函数指针调用方法
    cout << "3 + 5 = " << (calc.*operation)(3, 5) << endl;
    
    // 更改指向的成员函数
    operation = &Calculator::subtract;
    cout << "3 - 5 = " << (calc.*operation)(3, 5) << endl;
    
    return 0;
}

输出：

3 + 5 = 8
3 - 5 = -2

总结​

函数指针是 C++中一个强大的特性，它允许我们：

  1. 将函数作为参数传递给其他函数
  2. 在运行时动态选择要调用的函数
  3. 实现回调机制
  4. 创建灵活的、可扩展的系统架构

尽管函数指针的语法可能看起来有点复杂，但掌握它们将大大提高你的 C++编程能力，使你能够编写更加灵活和强大的程序。

在现代 C++中，std::function和lambda表达式使得函数指针的使用更加简单和灵活，但了解原始的函数指针仍然很重要，因为它们是这些现代特性的基础。

练习​

  1. 编写一个函数，接受一个整数数组、数组大小和一个函数指针作为参数，对数组中的每个元素应用该函数。
  2. 实现一个简单的计算器程序，使用函数指针数组来存储加、减、乘、除操作。
  3. 创建一个函数，根据传入的条件函数指针，对一个向量进行过滤。

进一步学习资源​

  • 探索 C++标准库中的算法，如std::sort、std::find_if等，它们都接受函数指针或函数对象作为参数。
  • 学习设计模式中的"策略模式"和"命令模式"，这些模式大量使用函数指针或类似概念。
  • 深入了解 C++11引入的std::function和lambda表达式，它们是函数指针的现代替代品。
提示

记住，函数指针是一个强大的工具，但也容易导致代码复杂难懂。在实际应用中，应当权衡其优势与可读性之间的关系。