函数的地址是存储其机器语言代码的内存的开始地址。可以编写将另一个函数的地址作为参数的函数，它允许在不同的时间传递不同函数的地址，这意味着可以在不同的时间使用不同的函数。

1 函数指针类型

声明指向函数的指针时，必须指定函数的返回类型以及函数的特征标（参数列表），可以首先编写这种函数的原型，然后用 (*pf) 替换函数名，这样 pf 就是这类函数的指针。以下面的程序为例，要获取函数的地址，只需使用函数名即可（后面不跟参数），这与数组地址有几分相似，函数指针 pf 的类型是 double (*)(int)，由于 pf 是指向 pam() 函数的指针，因此 (*pf) 是函数，使用函数指针调用函数时，C++ 将 pf 与 (*pf) 看作是等价的（虽然前者是函数指针，后者是函数），将 pf() 用作函数调用与将 (*pf)() 用作函数调用，效果一样。

//函数原型
double pam(int);

//声明对应的函数指针
double (*pf)(int);

//赋值，也可在声明时进行
pf = pam;

//使用函数指针调用函数，以下几种方式等效
double x = pam(4);   //方式一
double x = (*pf)(4); //方式二
double x = pf(4);    //方式三

//输出函数地址
cout << pam;  //值为0x001F1384
cout << pf;   //值为0x001F1384

对函数指针进行赋值时，对应函数的特征标和返回类型必须与 pf 相同，如果不相同，编译器将拒绝这种赋值。例如函数指针类型 const double * (*)(const double *, int) 与下面几种函数匹配，它们的特征标看似不同，但实际上相同，还可使用 auto 关键字自动推断函数指针的类型。

//函数原型
const double * f1(const double ar[], int n);
const double * f2(const double * ar, int n);
const double * f3(const double [], int);
const double * f4(const double *, int);

//声明函数指针
const double * (*pf)(const double *, int);

//赋值
pf = f1;
pf = f2;
pf = f3;
pf = f4;

//可使用自动类型推断
auto pff = f1;

假设要设计一个名为 estimate() 的函数，用于估算编写指定行数的代码所需的时间，而且允许每个程序员提供自己的算法来估算时间，此时可将函数地址作为该函数的输入参数，其函数原型可使用如下声明，需保证每个程序员提供的函数特征标和返回类型都一致且与 double (*)(int) 匹配。

//将函数指针作为函数参数
void estimate(int lines, double (*pf)(int));

2 函数指针数组

指向函数指针数组的指针通常用于类的虚方法实现中，细节通常由编译器自动处理。如下程序所示，函数指针数组大体性质与一维数组相似，其中需要注意的是：

• 运算符 () 与 [] 的优先级比 * 要高，因此需在合适的地方使用括号 () 提高 * 的优先级。
• 无法将指针算术运用于函数名，即出现 fb+1 或 arrpf[i]+1 时编译器会报错。
• 无法将 sizeof() 运用于函数名 fb ，但可用于 arrpf[i]，即出现 sizeof(fb) 时编译器会报错，但 sizeof(arrpf[i]) 则不会。

//函数原型
double fa(int);
double fb(int);
double fc(int);
double fd(int);

//声明并初始化函数指针数组
double (*arrpf[4])(int) = {fa,fb,fc,fd};

//声明并初始化指向函数指针数组第一个元素的指针，以下三种方式对arrpfb等效
double (**arrpfb)(int) = arrpf;     //方式一
double (**arrpfb)(int) = &arrpf[0]; //方式二
auto arrpfb = &arrpf[0];            //方式三

//声明并初始化指向整个函数指针数组的指针，以下两种方式对arrpfc等效
double (*(*arrpfc)[4])(int) = &arrpf; //方式一
auto arrpfc = &arrpf;                 //方式二

//调用函数fb，以下几种方式等效
int x = 5;
double y = fb(x);

double y = arrpf[1](x);
double y = (*arrpf[1])(x);
double y = (*(arrpf+1))(x);
double y = (**(arrpf+1))(x);

double y = arrpfb[1](x);
double y = (*arrpfb[1])(x);
double y = (*(arrpfb+1))(x);
double y = (**(arrpfb+1))(x);

double y = (*arrpfc)[1](x);
double y = (*(*arrpfc)[1])(x);
double y = (*(*arrpfc+1))(x);
double y = (**(*arrpfc+1))(x);

//应用指针算术时单位1表示的字节数(32系统)
cout << int(arrpf+1)-int(arrpf);        //结果为4
cout << int(&arrpf[0]+1)-int(&arrpf[0]);//结果为4
cout << int(&arrpf+1)-int(&arrpf);      //结果为16

cout << int(arrpfb+1)-int(arrpfb);      //结果为4
cout << int(arrpfc+1)-int(arrpfc);      //结果为16

//应用sizeof()获得内存量大小(32系统)
cout << sizeof(arrpf);    //结果为16
cout << sizeof(&arrpf[0]);//结果为4
cout << sizeof(&arrpf);   //结果为4
cout << sizeof(arrpf[0]); //结果为4

cout << sizeof(arrpfb);   //结果为4
cout << sizeof(arrpfc);   //结果为4

3 使用 typedef 进行简化

可将 typedef 关键字用于函数指针类型，简化程序的编写，如下所示，此时 p_fun 就是函数指针类型 double (*)(int) 的别名，上述数组以及指针声明可采用以下等效形式。

//指定函数指针别名
typedef double (*p_fun)(int);

//声明并初始化函数指针数组，与前面等效
p_fun arrpf[4] = {fa,fb,fc,fd};

//声明并初始化指向函数指针数组第一个元素的指针，与前面等效
p_fun* arrpfb = &arrpf[0]; 

//声明并初始化指向整个函数指针数组的指针，与前面等效
p_fun (*arrpfc)[4] = &arrpf;