C++函数指针

函数指针

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

例如：
 

int A(int a);

该函数的类型是int(int),注意不要形参名

要想声明一个可以指向该函数的指针，只需要用指针替换函数名即可：

int (*AA)(int);//AA是一个函数指针，指向的函数类型是int(int)
//目前AA未初始化

从我们声明的名字开始观察，AA前面有个*，因此AA是指针；右侧是形参列表，表AA指向的是函数；再观察左侧，发现函数的返回类型是int。

因此，AA就是一个指向函数的指针，其中该函数的参数是int类型。

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

//声明一个名为AA的函数，该函数返回int*
int *AA(int);

使用函数指针

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

例如，按照如下形式我们可以将A的地址赋给AA:

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

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

int b1 = AA(3); // 调用 lengthCompare 函数
int b2 = (*AA)(3); // 一个等价的调用
int b3 = A(3)；// 另一个等价的调用

在指向不同函数类型的指针间不存在转换规则。

但是和往常一样，我们可以为函数指针赋一个nullptr或者值为0的整型常量表达式，表示该指针没有指向任何一个函数：

int A(int a);
int B(char a);
float C(int a);


int main()
{
int(*AA)(int);

AA=0； // 正确：pf不指向任何函数
AA = C; //错误：返回类型不匹配
AA = B;// 错误：形参类型不匹配 
AA= A;//正确：函数和指针的类型精确匹配
}

 

重载函数的指针

当我们使用重载函数时，上下文必须清晰地界定到底应该选用哪个函数。

如果定义了指向重载函数的指针

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

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

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

函数指针形参

和数组类似，虽然不能定义函数类型的形参，但形参可以是指向函数的指针。

此时，形参看起来是函数类型，实际上却是当成指针使用：

//第三个形参是函数类型，它会自动地转换成指向函数的指针
void useA( int AA(int));


//等价的声明：显式地将形参定义成指向函数的指针
void useA (int (*AA) (int));

注意编译器会把第两个函数视为重复声明

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

// 自动将函数A转换成指向该函数的指针
useA(A);

#include<iostream>
using namespace std;
int A(int a)
{
	cout << "使用中" << endl;
	return 3;
}

void useA(int A(int))
{
	cout << "使用成功1" << endl;
}
void useA2(int (*A)(int))
{
	cout << "使用成功2" << endl;
}
int main()
{
	useA(A);
	useA2(A);
}

直接使用函数指针类型显得冗长而烦琐。

类型别名和decltype能让我们简化使用了函数指针的代码：

int A(int a);
int (*AA)(int);//AA是一个函数指针，指向的函数类型是int(int)

// Func 和 Func2是函数类型
typedef int Func(int);
typedef decltype(AA) Func2; // 等价的类型

// FuncP 和 FuncP2是指向函数的指针
typedef int(*FuncP) (int)；
typedef decltype(A) *FuncP2； // 等价的类型

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

可以使用如下的形式重新声明useA:

// useA的等价声明，其中使用了类型别名
void useA(Func);
void useA(FuncP2);

这两个声明语句声明的是同一个函数，在第一条语句中，编译器自动地将Func表示的函数类型转换成指针。

返回指向函数的指针

和数组类似，虽然不能返回一个函数，但是能返回指向函数类型的指针。然而，我们必须把返回类型写成指针形式，编译器不会自动地将函数返回类型当成对应的指针类型处理。与往常一样，要想声明一个返回函数指针的函数，最简单的办法是使用类型别名：

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

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

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

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

int (*f1(int))(int*, int)；

按照由内向外的顺序阅读这条声明语句：我们看到f1有形参列表，所以f1是个函数：f1前面有*，所以f1返回一个指针；进一步观察发现，指针的类型本身也包含形参列表，因此指针指向函数，该函数的返回类型是int。

出于完整性的考虑，有必要提醒读者我们还可以使用尾置返回类型的方式声明一个返回函数指针的函数：
 

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

将auto和decltype用于函数指针类型

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

int B(int a);
// 根据其形参的取值，getB 函数返回指向函数B 

decltype(B) *getB();

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