指向函数的指针

函数指针是指指向函数而非指向对象的指针。像其他指针一样，函数指针也指向某个特定的类型。函数类型由其返回类型以及形参表确定，而与函数名无关：

// pf points to function returning bool that takes two const string references
bool (*pf)(const string &, const string &);

这个语句将 pf 声明为指向函数的指针，它所指向的函数带有两个 const string& 类型的形参和 bool 类型的返回值。

*pf 两侧的圆括号是必需的：

// declares a function named pf that returns a bool*

bool *pf(const string &, const string &);

1、用 typedef 简化函数指针的定义

函数指针类型相当地冗长。使用 typedef 为指针类型定义同义词，可将函数指针的使用大大简化：

typedef bool (*cmpFcn)(const string &, const string &);

该定义表示 cmpFcn 是一种指向函数的指针类型的名字。该指针类型为“指向返回 bool 类型并带有两个 const string 引用形参的函数的指针”。在要使用这种函数指针类型时，只需直接使用 cmpFcn 即可，不必每次都把整个类型声明全部写出来。

       定义函数指针变量

      cmpFcn  pf1；//简化之前

bool (*pf2)(const string &, const string &); //未简化

2、指向函数的指针的初始化和赋值

在引用函数名但又没有调用该函数时，函数名将被自动解释为指向函数的指针。假设有函数：

// compares lengths of two strings

bool lengthCompare(const string &, const string &);

除了用作函数调用的左操作数以外，对 lengthCompare 的任何使用都被解释为如下类型的指针：

bool (*)(const string &, const string &);

可使用函数名对函数指针做初始化或赋值：

cmpFcn pf1 = 0; // ok: unbound pointer to function

cmpFcn pf2 = lengthCompare; // ok: pointer type matches function's type

pf1 = lengthCompare; // ok: pointer type matches function's type

pf2 = pf1; // ok: pointer types match

此时，直接引用函数名等效于在函数名上应用取地址操作符：

cmpFcn pf1 = lengthCompare;
cmpFcn pf2 = &lengthCompare;

函数指针只能通过同类型的函数或函数指针或 0 值常量表达式进行初始化或赋值。
将函数指针初始化为 0，表示该指针不指向任何函数。指向不同函数类型的指针之间不存在转换：

string::size_type sumLength(const string&, const string&);
bool cstringCompare(char*, char*);
// pointer to function returning bool taking two const string&

cmpFcn pf;
pf = sumLength; // error: return type differs
pf = cstringCompare; // error: parameter types differ

pf = lengthCompare; // ok: function and pointer types match exactly

3、通过指针调用函数

指向函数的指针可用于调用它所指向的函数。可以不需要使用解引用操作符，直接通过指针调用函数：

cmpFcn pf = lengthCompare;

lengthCompare("hi", "bye"); // direct call

pf("hi", "bye"); // equivalent call: pf1 implicitly dereferenced

(*pf)("hi", "bye"); // equivalent call: pf1 explicitly dereferenced

如果指向函数的指针没有初始化，或者具有 0 值，则该指针不能在函数调用中使用。只有当指针已经初始化，或被赋值为指向某个函数，方能安全地用来调用函数。

注意：赋值时，函数名或函数名取地址都会自动转换为函数取地址赋值给函数指针变量；使用时，函数指针变量都会自动转换为其取地址的值的调用。

4、函数指针形参

函数的形参可以是指向函数的指针。这种形参可以用以下两种形式编写：

/* useBigger function's third parameter is a pointer to function

* that function returns a bool and takes two const string references

* two ways to specify that parameter:

*/

// third parameter is a function type and is automatically treated as a pointer to function

void useBigger(const string &, const string &,bool (const string &, const string &));

// equivalent declaration: explicitly define the parameter as a pointer to function

void useBigger(const string &, const string &,bool (*)(const string &, const string &));

1.cpp //typedef简化后的调用

#include "stdafx.h"
#include<iostream>
using namespace std;
typedef void (*printT)(double);
void print(double i);
void traver(int i,printT a);
int _tmain(int argc, _TCHAR* argv[])
{
printT a=print;
traver(12,a);
getchar();
return 0;
}
void traver(int i,printT a){
a(i);
}
void print(double i){
cout<<i<<endl;
}

2.cpp  //声明不使用名字

#include "stdafx.h"
#include<iostream>
using namespace std;
void print(double i);
void traver(int i,void (double i));
int _tmain(int argc, _TCHAR* argv[])
{
void (*p)(double i);
p=print;
traver(12,p);
getchar();
return 0;
}
void traver(int i,void (*p)(double i)){
p(i);
}
void print(double i){
cout<<i<<endl;
}

3.cpp  //声明使用名字

#include "stdafx.h"
#include<iostream>
using namespace std;
void print(double i);
void traver(int i,void (*p)(double i));
int _tmain(int argc, _TCHAR* argv[])
{
void (*p)(double i);
p=print;
traver(12,p);
getchar();
return 0;
}
void traver(int i,void (*p)(double i)){
p(i);
}
void print(double i){
cout<<i<<endl;
}

5、返回指向函数的指针

函数可以返回指向函数的指针，但是，正确写出这种返回类型相当不容易：

// ff is a function taking an int and returning a function pointer

// the function pointed to returns an int and takes an int* and an int

int (*ff(int))(int*, int);

阅读函数指针声明的最佳方法是从声明的名字开始由里而外理解。
要理解该声明的含义，首先观察：

ff(int)

将 ff 声明为一个函数，它带有一个 int 型的形参。该函数返回

int (*)(int*, int);

它是一个指向函数的指针，所指向的函数返回 int 型并带有两个分别是int* 型和 int 型的形参。
使用 typedef 可使该定义更简明易懂：

// PF is a pointer to a function returning an int, taking an int* and an int

typedef int (*PF)(int*, int);

PF ff(int); // ff returns a pointer to function

允许将形参定义为函数类型，但函数的返回类型则必须是指向函数的指针，而不能是函数。具有函数类型的形参所对应的实参将被自动转换为指向相应函数类型的指针。但是，当返回的是函数时，同样的转换操作则无法实现：

// func is a function type, not a pointer to function!
typedef int func(int*, int);
void f1(func); // ok: f1 has a parameter of function type
func f2(int); // error: f2 has a return type of function type

func *f3(int); // ok: f3 returns a pointer to function type

6、指向重载函数的指针

C++ 语言允许使用函数指针指向重载的函数：

extern void ff(vector<double>);

extern void ff(unsigned int);

// which function does pf1 refer to?

void (*pf1)(unsigned int) = &ff; // ff(unsigned)

指针的类型必须与重载函数的一个版本精确匹配。如果没有精确匹配的函数，则对该指针的初始化或赋值都将导致编译错误：

// error: no match: invalid parameter list

void (*pf2)(int) = &ff;

// error: no match: invalid return type

double (*pf3)(vector<double>);

pf3 = &ff;