C/C++函数指针

April 10, 2022

函数的类型由其参数及返回类型共同决定，与函数名无关。

cpp

// 对于函数定义
int add(int nLeft,int nRight);
// 其类型为
int(int,int);

函数与其他数据类型不同的是，函数名位于形参列表之前，返回类型之后。
对于其他变量，类型在变量名之前，函数名却与函数类型是复合在一起的。

自然地，函数指针的声明如下。按照 C 风格，将 *pf 看作整体
用括号确保优先级，否则 * 将与 int 结合

cpp

int (*pf)(int,int);
// typedef的名称也是在相同的位置
typedef int (*PF)(int,int);
// 所以函数指针的类型为
int (*)(int,int);
// 不能这样
typedef int (*)(int, int) pFunc;

注意到 函数名 和 *函数名 和 &函数名 的地址都相同

cpp

#include <cstdio>
int add(int nLeft, int nRight)
{
    return nLeft + nRight;
}
int main()
{
    printf("%p\n", add);
    printf("%p\n", &add);
    printf("%p\n", *add);
}

输出（具体值取决于编译器）

00007ff623381591
00007ff623381591
00007ff623381591

cpp

#include <iostream>
using namespace std;
int add(int nLeft, int nRight)
{
    return nLeft + nRight;
}
template <typename T, typename U>
string judge(T t, U u)
{
    return t == u ? "true" : "false";
}
int main()
{
    cout << judge(add, &add) << endl; // true
    cout << judge(add, *add) << endl; // true
}

发现对于函数，* 表现得不正常
认为函数类似数组，函数名等同于函数的地址，即有 函数 == &函数
因此认为 * 对函数操作有特殊的语义，对函数地址解除引用得到的还是函数地址

函数指针则没有这种特殊待遇

cpp

#include <cstdio>
using namespace std;
int add(int nLeft, int nRight)
{
    return nLeft + nRight;
}
typedef int (*pFunc)(int, int);
int main()
{
    pFunc pf = add;
    printf("%p\n", add);
    printf("%p\n", pf);
    printf("%p\n", *pf);
    printf("%p\n", &pf);
}

输出

00007ff6c1f91540
00007ff6c1f91540
00007ff6c1f91540
00000096e93ff878

函数指针作为一个地址变量，当然有自己的地址。观察输出，发现函数指针等同于对函数指针解除引用 ，这也与普通指针不同
认为函数指针名有特殊的语义，等同于其引用的函数

上面的例子中，函数名与函数指针的地址相同，可以认为它们的类型也是相同的

cpp

#include <cstdio>
int add(int nLeft, int nRight)
{
    return nLeft + nRight;
}
int doSomething(int a, int b, int(f)(int, int))
{
    return f(a, b);
}
int main()
{
    int (*fp)(int, int) = add;
    printf("%d\n", doSomething(1, 2, fp)); // 3
    printf("%d\n", doSomething(1, 2, add)); // 3
}

更具体的例子

cpp

int main()
{
    int (*fp)(int, int) = add;
    int (*doSth1)(int, int, int(int, int)) = doSomething;
    int (*doSth2)(int, int, int (*)(int, int)) = doSomething;
    printf("%d\n", doSth1(1, 2, add)); // 3
    printf("%d\n", doSth1(1, 2, add)); // 3
    printf("%d\n", doSth1(1, 2, fp)); // 3
    printf("%d\n", doSth2(1, 2, fp)); // 3
}

对于返回函数指针的函数，其类型比较复杂

cpp

#include <cstdio>
int add(int a, int b)
{
    return a + b;
}
typedef int (*pFunc)(int, int);
pFunc fname(int useless)
{
    return add;
}
int (*fnamep(int useless))(int x, int y) // 这里注意，x和y可有可无，并且在函数体内无效
{// 完整定义，由内往外阅读。注意！fnamep是函数，返回函数指针（类型即上面的pFunc）。函数不能返回函数
    return add;
}
int main()
{
    printf("%d\n", fname(123)(1, 2)); // 3
    printf("%d\n", fnamep(123)(1, 2)); // 3
}

c++ 中可以使用 delctype 和 auto 自动推导类型

cpp

#include <iostream>
using namespace std;
int add(int a, int b)
{
    return a + b;
}
typedef decltype(add) add_t;
int main()
{
    add_t *add_func = add;
    auto add_func2 = add;
    cout << add_func(1, 2) << endl;  // 3
    cout << add_func2(1, 2) << endl; // 3
}

函数返回函数指针，更加直观

cpp

#include <iostream>
using namespace std;
int add(int a, int b)
{
    return a + b;
}
typedef decltype(add) add_t;
auto fnamep1(int useless) -> add_t *
{
    return add;
}
auto fnamep2(int useless) -> int (*)(int, int)
{
    return add;
}
decltype(add) *fnamep3(int useless)
{
    return add;
}
int main()
{
    cout << fnamep1(123)(1, 2) << endl; // 3
    cout << fnamep2(123)(1, 2) << endl; // 3
    cout << fnamep3(123)(1, 2) << endl; // 3
}

成员函数

cpp

#include <iostream>
using namespace std;
class Test
{
public:
    void hello()
    {
        cout << "hello" << endl;
    }
};
typedef void (Test::*CFP)();
CFP func = &Test::hello;

int main()
{
    Test test;
    (test.*func)();
}

←Back to home