88.函数指针

Posted 2023-05-09 codemagiciant

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

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

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

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

  从我们声明的名字开始观察，pf前面有个＊，因此pf是指针；右侧是形参列表，表示pf 指向的是函数，再观察左侧，发现函数的返回类型是布尔值。因此，pf就是一个指向函数的指针，其中该函数的参数是两个const string的引用，返回值是bool类型。

*pf两端的括号必不可少。如果不写这对括号，则pf是一个返回值为bool指针的函数：
//声明一个名为pf的函数，该函数返回bool*
bool *pf(const string&, const string&); 

1.使用函数指针

  当我们把函数名作为一个值使用时，该函数自动地转换成指针。例如，按照如下形式我们可以将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;//正确：函数和指针的类型精确匹配 

2.重载函数的指针

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

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的返回类型不匹配 

3.函数指针形参

  和数组类似（参见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页）能让我们简化使用了函数指针的代码：

//Fune和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定义自己的类型。Fune和Func2是函数类型，而FuncP和FuncP2是指针类型。需要注意的是，decltype返回函数类型，此时不会将函数类型自动转换成指针类型。因为decltype的结果是函数类型，所以只有在结果前面加上＊才能得到指针。可以使用如下的形式重新声明useBigger:

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

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

4.返回指向函数的指针

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

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

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

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

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

int (*fl (int))(int*, int); 

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

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

5.将 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++ Primer

类函数指针（不涵盖：返回类函数指针）

类函数指针的类型声明：

　　typedef 函数类型 (类名::*指针类型名)(函数参数, ...);

用以上类型定义指针变量：

　　指针类型名 指针名;

直接定义类函数指针：

　　函数类型 (类名::*指针名)([函数参数], ...);

将类成员函数的地址赋值给指针变量：

　　指针名 = &类名::函数名;

执行指针变量指向的类成员函数：

　　类名 对象名;

　　函数类型 变量名 = (对象名.*指针名)([形参]);

或

　　函数类型 变量名 = (this->*指针名)([形参]);

如果函数返回值类型是void，则用以下例子：

　　typedef void (类名::*指针名)([函数参数], ...);

 

　　指针名 = &类名::函数名;

　　(this->*指针名)([形参]);   或  类名 对象名;  (对象名.*指针名)([形参]);

---------------------------------------------------------------------------------------------------------------------------------------------------------

注意：使用 类函数指针作为类函数返回值 和 回调函数定义时的类函数指针参数 ，这两种写法需要将 类函数指针类型的声明 放在类定义的花括号内

---------------------------------------------------------------------------------------------------------------------------------------------------------

思考：秉着易懂的代码才是好代码的原则，为什么还要用 函数指针/类函数指针 呢？

答：一是为了实现回调机制，二是在Qt的信号与槽机制中，如果在槽函数里发送一个信号，是在该槽函数退出之后才会触发信号对应的槽函数的，

这样就导致槽函数不能及时被调用，于是我get到的解决办法就是通过类函数指针来解决这个问题。