函数指针(函数指针作为函数形参/函数类型作为函数返回类型)

函数指针是指向函数的指针变量。 因此“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是大体一致的。函数指针有两个用途：调用函数和做函数的参数。

#include<stdio.h>
int max(int x,int y){return (x>y? x:y);}
int main()
{
    int (*ptr)(int, int);
    int a, b, c;
    ptr = max;
    scanf("%d%d", &a, &b);
    c = (*ptr)(a,b);
    printf("a=%d, b=%d, max=%d", a, b, c);
    return 0;
}

以上来自百度百科

函数指针指向的是函数而非对象。和其他指针一样，函数指针指向某种特定类型。函数的类型由它的返回类型和形参类型共同决定，与函数名无关：

bool length_compare(const string &, const string &)；

该函数的类型是 bool(const string &, const string &)；想要声明一个指向该函数的指针，只要用指针替换函数名即可：

#include <iostream>
using namespace std;

bool leng_compare(const string &s1, const string &s2){
    return s1.size() > s2.size();
}

int main(void){
    //pf指向一个函数，该函数的参数是两个 const string 的引用，返回值是 bool 类型
    bool (*pf) (const string &, const string &);//未初始化
    return 0;
}

注意 *pf 两端的括号必不可少的。如果不写这对括号，则 pf 是一个返回值为 bool 指针的函数。

使用指针函数：

当我们把函数名作为一个值使用时，该函数自动地转换成指针：

#include <iostream>
using namespace std;

bool leng_compare(const string &s1, const string &s2){
    return s1.size() > s2.size();
}

int main(void){
    //pf指向一个函数，该函数的参数是两个 const string 的引用，返回值是 bool 类型
    bool (*pf) (const string &, const string &);//未初始化
    pf = leng_compare;//pf指向名为 leng_compare 的函数
    cout << &pf << endl;
    cout << *pf << endl;
    cout << pf << endl;

    pf = &leng_compare;//和上面的那条赋值语句是等价的，即取地址符是可选的
    cout << &pf << endl;
    cout << *pf << endl;
    cout << pf << endl;
    return 0;
}

此外，我们还能直接使用指向函数的指针调用该函数，无需提前解引用指针：

#include <iostream>
using namespace std;

bool leng_compare(const string &s1, const string &s2){
    return s1.size() > s2.size();
}

int main(void){
    //pf指向一个函数，该函数的参数是两个 const string 的引用，返回值是 bool 类型
    bool (*pf) (const string &, const string &);//未初始化
    pf = leng_compare;//pf指向名为 leng_compare 的函数
    bool flag1 = pf("acfjls", "fjsl");//调用leng_compare函数
    bool flag2 = (*pf)("fjlsfld", "jfs");//一个等价调用
    bool flag3 = leng_compare("fjslfjs", "jfkdl");//另一个等价调用
    return 0;
}

指向不同函数类型的指针间不存在转换规则。但是和往常一样，我们可以为函数指针赋一个 nullptr 或者值为 0 的常量表达式，表示该指针没有指向任何一个函数。

重载函数的指针：

当我们使用重载函数的指针时，上下文必须清晰地界定到底应该选用哪个函数。编译器通过指针类型确定选用哪个函数，指针类型必须与重载汉萨中的某一个精确匹配：

#include <iostream>
using namespace std;

int gel(int* x){}

int gel(unsigned int x){}

int main(void){
    int cnt = gel(1);//单独函数调用是可以不是精确匹配，只要能有最佳匹配即可
    // int (*pf1)(int) = gel;//错误：形参列表不能精确匹配
    // double (*pf2)(int*) = gel;//错误：和第一个gel函数返回类型不匹配，和第二个gel函数形参不匹配
    int (*pf3)(unsigned int) = gel;//正确
    return 0;
}

函数指针形参：

和数组类似，虽然不能定义函数类型的形参，但是形参可以是指向函数的指针。此时形参看起来是函数类型，实际上却是当成指针使用：

#include <iostream>
using namespace std;

bool length_compare(const string &, const string &){}

//第三个形参是函数类型，它会自动转换成指向函数的指针
void max(const string &s1, const string &s2, bool pf(const string &, const string &)){}
//等价声定义，显示地将形参定义成指向函数的指针
// void max(const string &s1, const string &s2, bool (*pf)(const string &, const string &)){};

int main(void){
    max("fjs", "jfls", length_compare);//把函数当作为实参使用，此时它会自动地转换成指针
    return 0;
}

可以使用 typedef 定义自己的类，简化函数使用函数指针：

#include <iostream>
using namespace std;

bool length_compare(const string &, const string &){}

// gel1 和 gel2 是等价的函数类型
typedef bool gel1(const string &, const string &);
typedef decltype(length_compare) gel2;

//gel3 和 gel4 是等价的指针类型
typedef bool(*gel3)(const string &, const string &);
typedef decltype(length_compare) *gel4;

//需要注意的是这里的 decltype 返回的是函数类型，此时不会将函数类型自动转换成指针类型，只有在 decltype 返回结果前加上 * 才能得到指针

void max(const string &s1, const string &s2, gel1){}//编译器自动将gel1转换成指针类型了

// void max(const string &s1, const string &s2, gel3){}//等价声明

int main(void){
    max("fjs", "jfls", length_compare);//把函数当作为实参使用，此时它会自动地转换成指针
    return 0;
}

返回指向函数的指针：

和数组类似，虽然不能返回一个函数，但是能返回指向函数类型的指针。然而，我们必须把返回类型写成指针的形式，编译器不会自动地将函数返回类型当成对应的指针类型处理。而想要声明一个返回函数指针的函数，可以直接声明，使用类型别名，尾置类型等：

#include <iostream>
using namespace std;

using gel1 = int(int*, int);//gel1是函数类型，不是指向函数的指针
using gel2 = int(*)(int*, int);//gel2是指向函数的指针
// typedef int (*gel3)(int*, int);//gel2的等价类型

// gel1 lou(int x);//错误：gel1是函数类型，不是指针类型
gel2 lou(int x);
gel1* lou(int x);
int (*lou(int x))(int *, int);//不使用类型别名，直接声明
auto lou(int) -> int (*)(int *, int);//使用尾置返回类型

int main(void){
    return 0;
}

使用 decltype：

当我们明确知道返回的函数是哪一个，就能使用 decltype 简化书写函数指针返回类型的过程，需要注意的是 decltype 返回的不是指针，需要添加 *，这点和数组是一样的：

#include <iostream>
using namespace std;

int gel(int *, int);

decltype(gel) *lou(int x);//注意这里的*不能落掉

int main(void){
    return 0;
}