C++ 指针高级用法函数指针

函数指针基础概念

在C++ 中，函数指针是一种特殊类型的指针，它指向的是函数而非变量。每个函数在内存中都有其特定的地址，函数指针就是用来存储这些地址的。通过函数指针，我们可以像调用普通函数一样来调用它所指向的函数。

函数指针的声明语法较为独特，其一般形式为：返回类型 (*指针变量名)(参数列表);。例如，对于一个返回 int 类型且接受两个 int 类型参数的函数，其函数指针声明如下：

int (*funcPtr)(int, int);

这里 funcPtr 就是一个函数指针，它可以指向任何返回 int 且接受两个 int 参数的函数。

函数指针的赋值

要使函数指针指向一个具体的函数，只需将函数名赋给函数指针即可（函数名在表达式中会被隐式转换为函数的地址）。假设有如下函数：

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

我们可以这样将 add 函数的地址赋给函数指针：

int (*funcPtr)(int, int);
funcPtr = add;

也可以在声明函数指针的同时进行赋值：

int (*funcPtr)(int, int) = add;

通过函数指针调用函数

一旦函数指针指向了一个函数，就可以通过它来调用该函数。调用方式与普通函数调用类似，只是使用函数指针代替函数名。例如：

int result = (*funcPtr)(3, 5);

这里通过 funcPtr 调用了 add 函数，并将返回值赋给 result。实际上，C++ 允许直接使用函数指针名称来调用函数，而不必使用解引用操作符 *，即：

int result = funcPtr(3, 5);

这两种调用方式在效果上是等价的。

函数指针作为函数参数

函数指针一个强大的用途是作为其他函数的参数。这种机制使得我们可以将不同的函数作为参数传递给另一个函数，从而实现代码的灵活性和可扩展性。例如，假设有一个函数 calculate，它接受两个整数和一个函数指针作为参数，并通过该函数指针来执行相应的运算：

int calculate(int a, int b, int (*operation)(int, int)) {
    return operation(a, b);
}

我们可以这样使用 calculate 函数：

int add(int a, int b) {
    return a + b;
}
int subtract(int a, int b) {
    return a - b;
}
int main() {
    int result1 = calculate(5, 3, add);
    int result2 = calculate(5, 3, subtract);
    return 0;
}

在上述代码中，calculate 函数根据传入的不同函数指针，分别执行加法和减法操作。

函数指针数组

函数指针数组是一个数组，其每个元素都是一个函数指针。这在需要根据不同条件调用不同函数的场景下非常有用。例如，假设我们有多个数学运算函数，并且希望通过一个索引来选择执行哪个函数：

int add(int a, int b) {
    return a + b;
}
int subtract(int a, int b) {
    return a - b;
}
int multiply(int a, int b) {
    return a * b;
}
int divide(int a, int b) {
    if (b != 0) {
        return a / b;
    }
    return 0;
}
int main() {
    int (*operationArray[4])(int, int) = {add, subtract, multiply, divide};
    int num1 = 10, num2 = 5;
    int index = 2;
    int result = operationArray[index](num1, num2);
    return 0;
}

在这个例子中，operationArray 是一个函数指针数组，通过改变 index 的值，我们可以选择执行不同的数学运算函数。

函数指针与回调函数

回调函数是一种通过函数指针实现的机制，它允许在某个事件发生或某个条件满足时调用一个预先指定的函数。例如，在一些图形用户界面（GUI）库中，当用户点击一个按钮时，系统会调用一个预先注册的回调函数来处理点击事件。

下面是一个简单的回调函数示例，模拟一个定时器，当定时器到期时调用一个回调函数：

#include <iostream>
#include <chrono>
#include <thread>

// 回调函数类型
using Callback = void (*)();

// 定时器函数，接受回调函数作为参数
void timer(int seconds, Callback callback) {
    std::this_thread::sleep_for(std::chrono::seconds(seconds));
    callback();
}

// 具体的回调函数实现
void onTimerExpired() {
    std::cout << "Timer has expired!" << std::endl;
}

int main() {
    std::cout << "Starting timer..." << std::endl;
    timer(5, onTimerExpired);
    return 0;
}

在上述代码中，timer 函数在等待指定的秒数后，调用传入的回调函数 onTimerExpired。

函数指针的类型检查与兼容性

在使用函数指针时，类型检查至关重要。函数指针的类型必须与它所指向的函数的类型完全匹配，包括返回类型和参数列表。例如，如果有一个函数指针声明为：

int (*funcPtr)(int, int);

那么它只能指向返回 int 且接受两个 int 参数的函数。如果尝试将其指向一个返回类型或参数列表不匹配的函数，会导致编译错误。

然而，在一些情况下，函数指针的参数列表可能存在一定的兼容性。例如，对于具有默认参数的函数，函数指针可以指向该函数，只要实际调用时提供的参数与函数指针声明的参数列表兼容。例如：

int add(int a, int b = 0) {
    return a + b;
}
int main() {
    int (*funcPtr)(int, int) = add;
    int result = funcPtr(5);
    return 0;
}

在这个例子中，funcPtr 可以指向 add 函数，并且在调用时只提供一个参数，因为 add 函数的第二个参数有默认值。

函数指针与面向对象编程

在C++ 的面向对象编程中，函数指针也有其应用场景。例如，在类的成员函数指针方面，它允许我们在运行时根据不同情况调用类的不同成员函数。

类的成员函数指针的声明语法与普通函数指针略有不同。对于一个类 MyClass，其成员函数指针的声明形式为：返回类型 (MyClass::*指针变量名)(参数列表);。例如：

class MyClass {
public:
    int add(int a, int b) {
        return a + b;
    }
    int subtract(int a, int b) {
        return a - b;
    }
};
int main() {
    MyClass obj;
    int (MyClass::*memberFuncPtr)(int, int);
    memberFuncPtr = &MyClass::add;
    int result = (obj.*memberFuncPtr)(3, 5);
    memberFuncPtr = &MyClass::subtract;
    result = (obj.*memberFuncPtr)(5, 3);
    return 0;
}

在上述代码中，memberFuncPtr 是 MyClass 类的成员函数指针，通过它可以调用 MyClass 的不同成员函数。

函数指针的局限性与替代方案

尽管函数指针在C++ 编程中非常有用，但它也存在一些局限性。例如，函数指针不能直接捕获局部变量，这在一些需要访问局部上下文的场景中会带来不便。

为了克服这些局限性，C++ 引入了一些替代方案，如 std::function 和 lambda 表达式。std::function 是一个通用的多态函数封装器，它可以封装任何可调用对象，包括函数指针、成员函数指针、lambda 表达式和仿函数。例如：

#include <iostream>
#include <functional>

int add(int a, int b) {
    return a + b;
}
int main() {
    std::function<int(int, int)> func = add;
    int result = func(3, 5);
    return 0;
}

lambda 表达式则是一种匿名函数，它可以方便地捕获局部变量。例如：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    int factor = 2;
    std::for_each(numbers.begin(), numbers.end(), [factor](int& num) {
        num *= factor;
    });
    for (int num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}

在这个例子中，lambda 表达式捕获了局部变量 factor，并在遍历 numbers 向量时使用它来对每个元素进行乘法操作。

函数指针在模板编程中的应用

在C++ 的模板编程中，函数指针也有着独特的应用。模板可以接受函数指针作为参数，从而实现更加通用和灵活的代码。例如，假设有一个模板函数 apply，它接受一个函数指针和两个参数，并通过函数指针来应用函数到这两个参数上：

template <typename ReturnType, typename Arg1, typename Arg2>
ReturnType apply(ReturnType (*func)(Arg1, Arg2), Arg1 a, Arg2 b) {
    return func(a, b);
}
int add(int a, int b) {
    return a + b;
}
double multiply(double a, double b) {
    return a * b;
}
int main() {
    int result1 = apply(add, 3, 5);
    double result2 = apply(multiply, 2.5, 3.5);
    return 0;
}

在上述代码中，apply 模板函数可以接受不同类型的函数指针，并根据传入的函数指针类型和参数类型进行相应的操作。

函数指针与动态链接库（DLL）

在Windows 平台上，动态链接库（DLL）是一种可执行文件，它包含了可以被多个程序共享的函数和数据。函数指针在与 DLL 交互中起着重要作用。通过函数指针，程序可以在运行时动态加载 DLL 并调用其中的函数。

首先，我们需要使用 Windows API 函数 LoadLibrary 来加载 DLL，然后使用 GetProcAddress 函数来获取 DLL 中函数的地址，并将其赋值给函数指针。例如，假设有一个名为 MathFunctions.dll 的 DLL，其中包含一个 Add 函数：

#include <iostream>
#include <windows.h>

typedef int (*AddFunc)(int, int);

int main() {
    HINSTANCE hDLL = LoadLibrary(TEXT("MathFunctions.dll"));
    if (hDLL != nullptr) {
        AddFunc addFunc = (AddFunc)GetProcAddress(hDLL, "Add");
        if (addFunc != nullptr) {
            int result = addFunc(3, 5);
            std::cout << "Result: " << result << std::endl;
        }
        FreeLibrary(hDLL);
    }
    return 0;
}

在上述代码中，LoadLibrary 加载 MathFunctions.dll，GetProcAddress 获取 Add 函数的地址并转换为 AddFunc 类型的函数指针，然后通过该函数指针调用 Add 函数。

函数指针的内存管理与生命周期

函数指针本身并不直接涉及内存分配和释放，因为它只是指向函数的地址，而函数的内存管理由编译器和操作系统负责。然而，当函数指针与动态分配的对象或资源相关联时，就需要注意内存管理和生命周期问题。

例如，如果函数指针指向的是一个类的成员函数，并且该类对象是通过 new 动态分配的，那么在释放对象时需要确保不再使用指向该对象成员函数的函数指针。否则，可能会导致悬空指针和未定义行为。

class MyClass {
public:
    void print() {
        std::cout << "Hello from MyClass" << std::cout;
    }
};
int main() {
    MyClass* obj = new MyClass();
    void (MyClass::*memberFuncPtr)() = &MyClass::print;
    (obj->*memberFuncPtr)();
    delete obj;
    // 以下代码会导致未定义行为
    // (obj->*memberFuncPtr)();
    return 0;
}

在上述代码中，删除 obj 后再通过 memberFuncPtr 调用成员函数会导致未定义行为，因为 obj 所指向的内存已经被释放。

函数指针在多线程编程中的注意事项

在多线程编程中使用函数指针需要特别小心。由于多个线程可能同时访问和调用函数指针所指向的函数，可能会引发竞态条件和数据不一致问题。

例如，如果多个线程通过同一个函数指针调用一个修改共享数据的函数，就需要使用同步机制（如互斥锁）来保护共享数据。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex dataMutex;
int sharedData = 0;

void increment() {
    std::lock_guard<std::mutex> lock(dataMutex);
    sharedData++;
}

int main() {
    void (*funcPtr)() = increment;
    std::thread threads[10];
    for (int i = 0; i < 10; i++) {
        threads[i] = std::thread(funcPtr);
    }
    for (auto& thread : threads) {
        thread.join();
    }
    std::cout << "Shared data: " << sharedData << std::endl;
    return 0;
}

在上述代码中，通过 std::mutex 和 std::lock_guard 来确保 increment 函数在多线程环境下对 sharedData 的安全访问。

函数指针的高级应用案例：策略模式实现

策略模式是一种软件设计模式，它定义了一系列算法，将每个算法封装起来，并使它们可以相互替换。函数指针可以很好地用于实现策略模式。

假设我们有一个图形绘制程序，需要支持不同的绘制策略（如绘制圆形、绘制矩形等）。我们可以定义不同的绘制函数，并使用函数指针来实现策略的切换。

#include <iostream>

// 绘制圆形函数
void drawCircle() {
    std::cout << "Drawing a circle" << std::endl;
}

// 绘制矩形函数
void drawRectangle() {
    std::cout << "Drawing a rectangle" << std::endl;
}

// 绘图策略类型
using DrawingStrategy = void (*)();

// 绘图上下文类
class DrawingContext {
private:
    DrawingStrategy strategy;
public:
    DrawingContext(DrawingStrategy s) : strategy(s) {}
    void draw() {
        strategy();
    }
};

int main() {
    DrawingContext circleContext(drawCircle);
    DrawingContext rectangleContext(drawRectangle);

    circleContext.draw();
    rectangleContext.draw();

    return 0;
}

在这个例子中，DrawingContext 类通过函数指针 DrawingStrategy 来持有不同的绘制策略，并在 draw 方法中调用相应的策略函数。这样，我们可以根据需要轻松地切换绘制策略。

函数指针在事件驱动编程中的应用

在事件驱动编程中，函数指针常用于注册事件处理函数。例如，在一个简单的命令行界面程序中，我们可能有不同的命令，每个命令对应一个处理函数。

#include <iostream>
#include <map>
#include <string>

// 处理命令的函数类型
using CommandHandler = void (*)();

// 帮助命令处理函数
void helpCommand() {
    std::cout << "Available commands: help, quit" << std::endl;
}

// 退出命令处理函数
void quitCommand() {
    std::cout << "Quitting the program..." << std::endl;
}

int main() {
    std::map<std::string, CommandHandler> commandMap;
    commandMap["help"] = helpCommand;
    commandMap["quit"] = quitCommand;

    std::string input;
    while (true) {
        std::cout << "Enter command: ";
        std::cin >> input;
        auto it = commandMap.find(input);
        if (it != commandMap.end()) {
            it->second();
            if (input == "quit") {
                break;
            }
        } else {
            std::cout << "Unknown command. Type 'help' for help." << std::endl;
        }
    }
    return 0;
}

在上述代码中，commandMap 使用字符串命令作为键，函数指针 CommandHandler 作为值，来存储不同命令对应的处理函数。用户输入命令后，程序查找相应的函数指针并调用对应的处理函数。

函数指针在信号处理中的应用

在一些系统编程场景中，函数指针可用于信号处理。例如，在Unix - like 系统中，可以使用 signal 函数来注册信号处理函数。信号处理函数通常是一个符合特定原型的函数，我们可以使用函数指针来指向这些信号处理函数。

#include <iostream>
#include <csignal>

// 信号处理函数
void signalHandler(int signum) {
    std::cout << "Received signal: " << signum << std::endl;
    // 执行清理操作等
}

int main() {
    // 注册信号处理函数
    std::signal(SIGINT, signalHandler);

    std::cout << "Press Ctrl+C to send a signal..." << std::endl;
    while (true) {
        // 程序主循环
    }
    return 0;
}

在上述代码中，std::signal 函数接受信号编号（如 SIGINT 表示 Ctrl + C 信号）和一个函数指针，该函数指针指向信号处理函数 signalHandler。当程序接收到 SIGINT 信号时，会调用 signalHandler 函数。

通过深入了解函数指针的各种用法和注意事项，我们可以在C++ 编程中更好地利用这一强大工具，实现更灵活、高效和可维护的代码。无论是在面向对象编程、模板编程、多线程编程还是各种设计模式和应用场景中，函数指针都有着独特的价值和应用。同时，我们也要注意其局限性，并结合C++ 提供的其他特性（如 std::function、lambda 表达式等）来编写更健壮的代码。在实际项目中，根据具体需求合理选择使用函数指针及其替代方案，将有助于提升程序的质量和性能。