C++Primer学习（6.7 函数指针——难！）

6.7 函数指针 (这一章节比较难)
函数指针指向的是函数而非对象。和其他指针一样，函数指针指向某种特定类型。函数的类型由它的返回类型和形参类型共同决定，与函数名无关。例如:

//比较两个 string 对象的长度
bool lengthCompare(const string &,const string &);

该函数的类型是 bool(conststring&，conststring&)。要想声明一个可以指向该函数的指针，只需要用指针替换函数名即可:

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

从我们声明的名字开始观察，pf前面有个 *，因此pf是指针;右侧是形参列表，表示pf指向的是函数;再观察左侧，发现函数的返回类型是布尔值。因此，pf就是一个指向函数的指针，其中该函数的参数是两个const string的引用，返回值是boo1类型。
*pf 两端的括号必不可少。如果不写这对括号，则pf是一个返回值为 bool指针的函数:

//声明一个名为pf的函数，该函数返回 bool * 
bool * pf(const string &，const string &);

使用函数指针
当我们把函数名作为一个值使用时，该函数自动地转换成指针。例如，按照如下形式我们可以将 lengthCompare的地址赋给pf:

pf = lengthCompare;//pf 指向名为 lengthCompare 的函数
pf = &lengthCompare;//等价的赋值语句:取地址符是可选的

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

bool bl =pf("hello","goodbye");//调用lengthCompare 函数
bool b2=(*pf)("hello"，"goodbye");//一个等价的调用
bool b3=lengthCompare("hello"，"goodbye");// 另一个等价的调用

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

string::size_type sumLength(const string &,const string &);
bool cstringCompare(const char*，const char*);
pf = 0;//正确:pf 不指向任何函数
pf = sumLength;//错误:返回类型不匹配
pf = cstringCompare;//错误:形参类型不匹配
pf = lengthCompare;//正确:函数和指针的类型精确匹配

重载函数的指针
当我们使用重载函数时，上下文必须清晰地界定到底应该选用哪个函数。如果定义了指向重载函数的指针

void ff(int*);
void ff(unsigned int);
void(*pfl)(unsigned int)=ff;//pfl指向ff(unsigned)

编译器通过指针类型决定选用哪个函数，指针类型必须与重载函数中的某一个精确匹配

void(*pf2)(int)=ff;//错误:没有任何一个ff与该形参列表匹配
double(*pf3)(int*)=ff;//错误:ff和pf3的返回类型不匹配

函数指针形参
和数组类似(参见6.2.4节，第193页)，虽然不能定义函数类型的形参，但是形参可以是指向函数的指针。此时，形参看起来是函数类型，实际上却是当成指针使用:

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

我们可以直接把函数作为实参使用，此时它会自动转换成指针:

//自动将函数lengthCompare转换成指向该函数的指针
useBigger(s1,s2，lengthCompare);

正如useBigger的声明语句所示，直接使用函数指针类型显得冗长而烦琐。类型别名(参见2.5.1节，第60页)和decltype(参见2.5.3节，第62页)能让我们简化使用了函数指针的代码:

//Func和Func2是函数类型
typedef bool Func(const string&,const string&);
typedef decltype(lengthCompare) Func2;//等价的类型
//FuncP 和FuncP2是指向函数的指针
typedef bool(*FuncP)(const string&,const string&);
typedef decltype(lengthCompare) *FuncP2;//等价的类型

我们使用 typedef定义自己的类型。Func和Func2是函数类型，而Funcp和FuncP2是指针类型。需要注意的是，decltype返回函数类型，此时不会将函数类型自动转换成指针类型。因为decltype的结果是函数类型,所以只有在结果前面加上*才能得到指针。可以使用如下的形式重新声明useBigger:

//useBigger的等价声明，其中使用了类型别名
void useBigger(const string&,const string&,Func);
void useBigger(const string&,const string&,FuncP2);

这两个声明语句声明的是同一个函数，在第一条语句中，编译器自动地将Func 表示的函数类型转换成指针。
返回指向函数的指针
和数组类似(参见6.3.3节，第205页)，虽然不能返回一个函数，但是能返回指向函数类型的指针。然而，我们必须把返回类型写成指针形式，编译器不会自动地将函数返回类型当成对应的指针类型处理。与往常一样，要想声明一个返回函数指针的函数，最简单的办法是使用类型别名:

using F=int(int*，int);//F是函数类型，不是指针
using PF=int(*)(int*,int);//PF 是指针类型

其中我们使用类型别名(参见2.51节，第60页)将F定义成函数类型，将PF定义成指向函数类型的指针。必须时刻注意的是，和函数类型的形参不一样，返回类型不会自动地转换成指针。我们必须显式地将返回类型指定为指针:

PF f1(int);//正确:PF是指向函数的指针，f1返回指向函数的指针
F fl(int);//错误:F是函数类型，f1不能返回一个函数
F *f1(int);//正确:显式地指定返回类型是指向函数的指针

当然，我们也能用下面的形式直接声明f1:

int (*fl(int))(int*，int);

按照由内向外的顺序阅读这条声明语句:我们看到f1有形参列表，所以f1是个函数:f1前面有 *，所以f1返回一个指针;进一步观察发现，指针的类型本身也包含形参列表,因此指针指向函数，该函数的返回类型是int。
出于完整性的考虑，有必要提醒读者我们还可以使用尾置返回类型的方式(参见6.3.3节，第206页)声明一个返回函数指针的函数:

auto fl(int)->int(*)(int*,int);

将 auto 和 decltype 用于函数指针类型
如果我们明确知道返回的函数是哪一个，就能使用decltype 简化书写函数指针返回类型的过程。例如假定有两个函数，它们的返回类型都是string::size_type，并且各有两个 const string&类型的形参，此时我们可以编写第三个函数，它接受一个string类型的参数，返回一个指针，该指针指向前两个函数中的一个:

string::size_type sumlength(const string&,const string&);
string::size_type largerlength(const string&,const string&);
//根据其形参的取值，getFcn函数返回指向sumLength或者largerLength的指针
decltype(sumLength)*getFcn(const string &);

声明 getFcn 唯一需要注意的地方是，牢记当我们将 decltype 作用于某个函数时，它返回函数类型而非指针类型。因此，我们显式地加上* 以表明我们需要返回指针，而非函数本身。

重新学一遍这些内容：

在 C++ 中，函数指针是一种特殊的指针类型，它指向函数而非对象。函数指针在实现回调机制、动态调用函数等方面有着重要的应用。以下从定义、声明、使用方法、应用场景等方面进行详细介绍：
定义和声明
函数指针的声明需要指定函数的返回类型、参数列表，语法格式如下：

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

下面是一个简单的示例：

#include <iostream>
// 定义一个函数
int add(int a, int b) 
{return a + b;
}
int main() 
{// 声明一个函数指针，指向返回类型为 int，参数为两个 int 类型的函数int (*funcPtr)(int, int);// 将函数指针指向 add 函数funcPtr = add;return 0;
}

在上述代码中，int (*funcPtr)(int, int); 声明了一个函数指针 funcPtr，它可以指向返回类型为 int，参数为两个 int 类型的函数。然后将其指向了 add 函数。
使用函数指针调用函数
通过函数指针调用函数的方式和直接调用函数类似，使用 (*指针名) 或者直接使用指针名来调用函数，示例如下：

#include <iostream>
// 定义一个函数
int add(int a, int b) 
{return a + b;
}
int main() 
{// 声明一个函数指针，指向返回类型为 int，参数为两个 int 类型的函数int (*funcPtr)(int, int);// 将函数指针指向 add 函数funcPtr = add;// 使用函数指针调用函数int result = (*funcPtr)(3, 5);  // 方式一// 或者 int result = funcPtr(3, 5);  // 方式二std::cout << "Result: " << result << std::endl;return 0;
}

函数指针作为参数传递
函数指针可以作为参数传递给其他函数，这样可以实现回调机制，使得函数的行为更加灵活。示例如下：

#include <iostream>
// 定义一个函数
int add(int a, int b) 
{return a + b;
}int subtract(int a, int b) 
{return a - b;
}
// 一个接受函数指针作为参数的函数
int calculate(int (*operation)(int, int), int a, int b) 
{return operation(a, b);
}int main() 
{int num1 = 10, num2 = 5;// 调用 calculate 函数，传递 add 函数指针int result1 = calculate(add, num1, num2);std::cout << "Addition result: " << result1 << std::endl;// 调用 calculate 函数，传递 subtract 函数指针int result2 = calculate(subtract, num1, num2);std::cout << "Subtraction result: " << result2 << std::endl;return 0;
}

在上述代码中，calculate 函数接受一个函数指针 operation 作为参数，通过这个函数指针可以动态地选择不同的操作（加法或减法）。
函数指针数组
可以创建函数指针数组，将多个函数指针存储在数组中，方便根据需要选择调用不同的函数。示例如下：

#include <iostream>
// 定义几个函数
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 main() 
{// 声明一个函数指针数组int (*funcArray[3])(int, int) = {add, subtract, multiply};int num1 = 10, num2 = 5;// 遍历函数指针数组并调用函数for (int i = 0; i < 3; ++i) {int result = funcArray[i](num1, num2);std::cout << "Result of operation " << i + 1 << ": " << result << std::endl;}return 0;
}

注意事项
函数签名匹配：函数指针的返回类型和参数列表必须与所指向的函数完全匹配，否则会导致编译错误。
指针空值检查：在使用函数指针之前，最好检查其是否为 nullptr，避免调用空指针导致程序崩溃。例如：

if (funcPtr != nullptr) 
{int result = funcPtr(3, 5);
}

返回指向函数的指针
声明返回指向函数的指针时，语法较为复杂，一般形式如下：

返回类型 (*函数名(参数列表))(返回类型, 参数列表);

下面逐步解释这个复杂的声明：
最外层的 函数名(参数列表) 是一个普通的函数声明，表示这是一个函数，括号内是该函数的参数列表。
(*函数名(参数列表)) 表明这个函数返回的是一个指针。
最后的 (返回类型, 参数列表) 是该指针所指向的函数的参数列表，而整个声明的开头的 返回类型 是该指针所指向的函数的返回类型。

#include <iostream>
// 定义几个简单的函数
int add(int a, int b) 
{return a + b;
}int subtract(int a, int b) 
{return a - b;
}// 返回指向函数的指针的函数
int (*getOperation(int choice))(int, int) 
{if (choice == 1) {return add;} else {return subtract;}
}int main() 
{int choice;std::cout << "Enter 1 for addition, 2 for subtraction: ";std::cin >> choice;// 获取函数指针int (*operation)(int, int) = getOperation(choice);int num1 = 10, num2 = 5;int result = operation(num1, num2);std::cout << "Result: " << result << std::endl;return 0;
}

在上述代码中：
add 和 subtract 是两个简单的函数，分别实现加法和减法操作。
getOperation 函数根据用户输入的 choice 值，返回指向 add 或 subtract 函数的指针。
在 main 函数中，调用 getOperation 函数获取函数指针，然后使用该指针调用相应的函数进行计算。
使用 typedef 简化声明
由于返回指向函数的指针的声明语法较为复杂，使用 typedef 可以简化声明。示例如下：

#include <iostream>
// 定义几个简单的函数
int add(int a, int b) 
{return a + b;
}int subtract(int a, int b) 
{return a - b;
}
// 使用typedef简化函数指针类型的声明
typedef int (*Operation)(int, int);
// 返回指向函数的指针的函数，使用简化后的类型
Operation getOperation(int choice) 
{if (choice == 1) {return add;} else {return subtract;}
}int main() 
{int choice;std::cout << "Enter 1 for addition, 2 for subtraction: ";std::cin >> choice;// 获取函数指针Operation operation = getOperation(choice);int num1 = 10, num2 = 5;int result = operation(num1, num2);std::cout << "Result: " << result << std::endl;return 0;
}

空指针检查：在使用返回的函数指针之前，最好检查其是否为 nullptr，避免调用空指针导致程序崩溃。例如：

Operation operation = getOperation(choice);
if (operation != nullptr) 
{int result = operation(num1, num2);
}