C++基础 | 函数指针

在C++编程中，函数指针是一个强大且灵活的工具，它允许我们将函数作为参数传递给其他函数，或者将函数存储在数据结构中。理解函数指针的概念及其用法，对于编写高效、灵活的代码至关重要。本文将详细介绍C++中的函数指针，探讨其细节和注意事项，并通过示例代码帮助读者更好地理解这一概念。

1. 什么是函数指针？

函数指针是指向函数的指针变量。与普通指针不同，函数指针存储的是函数的地址，而不是数据。通过函数指针，我们可以间接调用函数，甚至可以将函数作为参数传递给其他函数。

1.1 函数指针的声明

函数指针的声明语法如下：

返回类型 (*指针变量名)(参数类型列表);

例如，声明一个指向返回int类型、接受两个int类型参数的函数的指针：

int (*funcPtr)(int, int);

1.2 函数指针的初始化与赋值

函数指针可以通过将函数名赋值给它来初始化。函数名本身就是一个指向该函数的指针。

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

int main() {
    int (*funcPtr)(int, int) = add;  // 初始化函数指针
    int result = funcPtr(2, 3);      // 通过函数指针调用函数
    std::cout << "Result: " << result << std::endl;  // 输出: Result: 5
    return 0;
}

以上这种定义方式看上去比较繁琐，所以我们可以使用typedef为函数指针起一个别名：

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

typedef double (*MyFunc)(int, int);

int main() {
    MyFunc func = add;	// 与定义普通函数指针相同，只不过用起来更加方便
    int result = func(2, 3);
    cout << "Result: " << result << endl;
    return 0;
}

或者，使用typedef定义一个没有指针的函数类型，然后在代码中使用指针的形式定义函数指针：

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

typedef int (MyFunc)(int, int);

int main() {
    MyFunc* func = add;	// 与定义普通函数指针相同，只不过用起来更加方便
    int result = func(2, 3);
    cout << "Result: " << result << endl;
    return 0;
}

再或者，使用auto关键字帮助我们定义函数指针：

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

int main() {
    auto funcPtr = add;	
    int result = funcPtr(2, 3);
    cout << "Result: " << result << endl;
    return 0;
}

auto的局限性在于只能在初始化单个变量时使用，如果想初始化一个函数指针的数组时无法使用：

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

typedef int (*MyFunc)(int, int);

int main() {
    // auto ptrs[2] = { add, multiply };	// 语法错误
    MyFunc ptrs[2] = { add, multiply };
    int result = ptrs[0](2, 3);
    cout << "Result: " << result << endl;
    return 0;
}

2. 函数指针的使用场景

2.1 作为函数参数

函数指针最常见的用途之一是作为函数参数。这使得我们可以将不同的函数传递给同一个函数，从而实现回调机制或策略模式。

void printHello() {
    cout << "Hello, World!" << endl;
}

void printGoodbye() {
    cout << "Goodbye, World!" << endl;
}

void executeFunction(void (*func)()) {
    func();
}

int main() {
    executeFunction(printHello);    // 输出: Hello, World!
    executeFunction(printGoodbye);  // 输出: Goodbye, World!
    return 0;
}

2.2 作为返回值

函数指针也可以作为函数的返回值。这在某些高级编程场景中非常有用，例如工厂模式或插件系统。

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

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

int (*getFunction(bool isAdd))(int, int) {
    if (isAdd) {
        return add;
    } else {
        return subtract;
    }
}

int main() {
    int (*funcPtr)(int, int) = getFunction(true);
    cout << "Result: " << funcPtr(5, 3) << endl;  // 输出: Result: 8

    funcPtr = getFunction(false);
    cout << "Result: " << funcPtr(5, 3) << endl;  // 输出: Result: 2
    return 0;
}

3. 函数指针的注意事项

3.1 函数签名必须匹配

函数指针的类型必须与其指向的函数的签名完全匹配。如果函数签名不匹配，编译器将报错。

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

int main() {
    int (*funcPtr)(int) = add;  // 错误：函数签名不匹配
    return 0;
}

3.2 函数指针与重载函数

当函数重载时，函数指针必须明确指向特定的重载版本。编译器无法自动推断出应该使用哪个重载函数。

void print(int i) {
    cout << "Integer: " << i << endl;
}

void print(double d) {
    cout << "Double: " << d << endl;
}

int main() {
    void (*funcPtrInt)(int) = print;    // 指向print(int)
    void (*funcPtrDouble)(double) = print;  // 指向print(double)

    funcPtrInt(42);        // 输出: Integer: 42
    funcPtrDouble(3.14);   // 输出: Double: 3.14
    return 0;
}

3.3 函数指针与成员函数

普通函数指针不能直接指向类的成员函数，因为成员函数有一个隐式的this指针。如果需要指向成员函数，可以使用成员函数指针。

class MyClass {
public:
    void print() {
        cout << "Hello from MyClass!" << endl;
    }
};

int main() {
    void (MyClass::*funcPtr)() = &MyClass::print;  // 成员函数指针
    MyClass obj;
    (obj.*funcPtr)();  // 输出: Hello from MyClass!
    return 0;
}

4. 函数指针与Lambda表达式

C++11引入了Lambda表达式，它可以被视为一种匿名函数。Lambda表达式可以隐式转换为函数指针，前提是它不捕获任何变量。

int main() {
    auto lambda = [](int a, int b) { return a + b; };
    int (*funcPtr)(int, int) = lambda;  // Lambda表达式转换为函数指针
    cout << "Result: " << funcPtr(2, 3) << endl;  // 输出: Result: 5
    return 0;
}