与数据项（比如int、string、char等）相似，函数也有地址。
函数的地址是存储其机器语言代码的内存的开始地址（不懂）。
这些地址对用户而言，没什么用，也不重要，但对程序而言，却很有用。
例如，可以编写将另外一个函数的地址作为参数的函数。这样，第一个函数将能够找到第二个函数，并运行它。
与直接调用第二个函数相比，这种方法很笨拙，但他允许在不同的时间传递不同函数的地址，这意味着可以在不同的时间使用不同的函数。
函数指针和指针函数的区别：
函数指针：指向某个函数的指针（即这个指针指向函数的地址）；
指针函数：返回值是指针的函数
函数指针的基础知识：
函数的地址：
函数名 就是函数的地址（像字符串一样）；
声明函数指针：
有些像函数返回指针，但是要把*和函数名用括号括起来。例如：函数类型 (*函数名) (参数);
注意：①声明的函数指针，要和函数的特征标（例如类型、函数的参数类型）要相符；
②*函数名 此时是函数，而 函数名 此时是指针。
函数指针作为参数时：
函数类型 函数名(函数类型 (*函数名)(函数指针的参数类型) );
注：蓝色部分为函数指针作为参数时的写法。
调用函数指针时：
和声明函数指针类似，用函数指针的 (*函数名) 取代普通函数 函数名 即可。
如：(*函数名)(函数指针的参数) 这样。
也可以像使用普通函数那样，通过 函数名(参数) 这样调用函数，C++是允许这样做的。
给函数指针赋值时：
首先，函数指针和函数的特征标要相符。
然后例如代码节选：
void ab(int);//函数原型
void(*c)(int);
//函数指针原型
c = ab; //让函数指针c指向函数ab。这行代码一般在函数里
这样。
无返回值、将函数指针赋值、声明函数指针、调用函数指针，如代码：
#include<iostream>
using namespace std;
void ab(int); //函数1
void ef(int); //函数2
void(*c)(int); //声明函数指针，注意，这行代码放在main()函数内也可以
int main()
{
int a = 5;
c = ab; //函数指针指向函数1
c(a); //调用函数指针（即执行函数1）
c = ef; //函数指针指向函数2
(*c)(a); //调用函数指针（此时执行函数2），注意c和(*c)是等价的，不能省略括号
system("pause");
return 0;
}
void ab(int m)
{
cout << "m = " << m << endl;
}
void ef(int m)
{
cout << "m = " << m * 2 << endl;
}
输出：
m = 5 m = 10 请按任意键继续. . .
解释：
①这行代码就是函数指针指向不同函数时，同样的变量作为参数，却执行不同的函数。
有返回值、将函数指针作为函数的参数、不同情况下指向不同的函数、使用函数的地址，如代码：
#include<iostream>
using namespace std;
int ab(int); //函数1
int ef(int); //函数2
int c(int(*x)(int),int y); //引入函数指针作为函数c的参数
int main()
{
int a = 5;
int m, n;
m = c(ab, a); //调用的时候，指定ab函数作为参数
n = c(ef, a); //调用的时候，制定ef为指定的函数
cout << "m = " << m << endl;
cout << "n = " << n << endl;
system("pause");
return 0;
}
int ab(int m)
{
return m + 3;
}
int ef(int m)
{
return m * 3;
}
int c(int(*x)(int),int y) //x指向某个函数，y为函数将使用的参数。因此，在调用的时候，需要指定使用哪个函数。
{
return x(y); //返回 调用指针指向的函数(参数)的返回值
}
输出：
m = 8 n = 15 请按任意键继续. . .
总结：
①以上两部分代码，涉及到了函数的地址（即函数名）、声明函数指针、函数指针作为参数、调用函数指针、给函数指针赋值 这五个概念；
②可以在函数内部声明函数指针，然后根据变量的不同，让指针指向其他不同的函数，再执行对应的函数，并将对应函数的返回值作为函数的返回值。
如代码：
int c(int y)
//x指向某个函数，y为函数将使用的参数。因此，在调用的时候，需要指定使用哪个函数。
{
int(*x)(int);
//声明函数指针x
if(y<10)x=ab; else x=ef;
//不同参数y，让x指向不同的指针
return x(y);
//调用函数指针，y作为参数，返回值作为函数c的返回值
}
③A函数指针作为参数时，可以传递不同的函数名（例如B或者C）作为参数，使得在A函数中根据传递的函数名的不同，执行不同的函数（B或者C）。
当函数返回值为指针的函数指针：
|
函数 |
示例函数原型 |
|
普通函数 |
int abc(int); |
|
函数指针 |
int (*m) (int); |
|
返回值为指针的函数 |
int* abc (int); |
|
返回值为指针的函数指针 |
int* (*m) (int); |
可以发现，无论是指向普通函数，还是指向返回值为指针的函数，函数指针都是用(*指针名)替代函数名。就像(*m)替代abc 一样。
不同参数让指针指向不同的函数，代码：
#include<iostream>
using namespace std;
int*m(int);
int*n(int);
int main()
{
int*(*abc)(int); //创建一个函数指针，面对对象是返回值是指针的函数
int *l; //创建一个指针，将函数的返回值（指针）赋值给他。
for (int i = 0;i < 5;i++)
{
if (i % 2 == 0) //函数指针能被2整除时，指向m，不能被2整除时，指向n
{
abc = m;
}
else
{
abc = n;
}
l = abc(i+1); //执行函数指针，将返回值赋值给指针l。参数是i+1
cout << i+1 << "#:" << endl; //第（i+1）#
cout << "l = " << l << endl << " *l = " << *l << endl << endl; //打印l（指针）和l指向的地址的值
}
system("pause");
return 0;
}
int *m(int a)
{
int *x = new int; //new一个int地址出来
*x = a; //新地址的值是参数a
return x; //返回地址
}
int *n(int a)
{
int *x = new int; //new一个int地址出来
*x = a*2; //新地址的值是参数a*2
return x; //返回地址
}
输出：
1#: l = 00740A10 *l = 1 2#: l = 00740A40 *l = 4 3#: l = 00740670 *l = 3 4#: l = 00740CA0 *l = 8 5#: l = 00740CD0 *l = 5 请按任意键继续. . .
解释：
①当参数i（根据for循环而变）能否被2整除，让函数指针指向不同的函数；
声明一个函数指针数组：
除了上面声明一个函数指针，利用if语句使得指针指向不同函数，也可以声明一个函数指针数组，然后修改数组的成员标号，来让其指向不同的函数。
例如：
函数类型* (*函数名[函数指针成员个数]) (参数类型) ={ 函数1, 函数2};
可以将上面的代码
int*(*abc)(int); //创建一个函数指针，面对对象是返回值是指针的函数
int *l; //创建一个指针，将函数的返回值（指针）赋值给他。
for (int i = 0;i < 5;i++)
{
if (i % 2 == 0) //函数指针能被2整除时，指向m，不能被2整除时，指向n
{
abc = m;
}
else
{
abc = n;
}
l = abc(i+1); //执行函数指针，将返回值赋值给指针l。参数是i+1
……以下略……
改为：
int*(*abc[2])(int) = { m,n }; //创建一个 函数指针 数组，成员分别指向不同的函数
int *l; //创建一个指针，将函数的返回值（指针）赋值给他。
for (int i = 0;i < 5;i++)
{
l = abc[i%2](i+1); //利用i/2求余，调用不同的函数指针数组成员，并将返回值赋给指针l
……以下略……
输出结果是相同的，但减少了代码量。
原理：
①不同函数指针数组成员指向不同函数；
②然后利用成员编号（abc[i]）的不同，通过i%2的结果，得到不同的函数指针成员，再指向不同的函数（m或者n）。
③使用函数指针数组，就像使用普通的指针数组那样，把“[ ]”加在函数名后即可。
④关于auto：auto的效果是根据赋值来源的类型，自动为变量提供类型推断。
例如int a=4; auto b=a; 则b也是int类型。
auto只能用于单值类型初始化，比如在上面那个代码中，加入：auto b=m;
则相当于 int*(*b)(int)=m; 这样
又因为auto只能单值，因此不能auto b={m,n}; 这样，在后面的代码是不能b[0]调用m，b[1]调用n的。
但是，可以：
int*(*abc[2])(int) = { m,n };
//创建一个 函数指针 数组，成员分别指向不同的函数
auto b = abc;
这样，在后面的代码，可以用b[i]代替abc[i]了；
函数指针的地址：
指针赋值：int a; int *b=&a; 这样的格式
重要：函数的名字是函数，字符串、数组的名字也只是字符串和数组；
只不过，在大多数情况下（例如不加地址运算符&），他被转化为指向他本身的指针。
如代码：
#include<iostream>
using namespace std;
int* a1(void);
int* a2(void);
int* a3(void);
int main()
{
int*(*b1)(void); //b1是一个函数指针，他可以指向a1~a3中的某一个函数
b1 = a1; //指针b1指向函数a1，则b1输出的是函数a1的地址，
//b1()是调用函数b1，然后得到其返回值（int指针）。
//*b1是b1指针指向的值（依然是函数a1，和b1等价）
//(*b1)()和b1()是等价的。都是函数a1的返回值（这里是一个指针）
//*b1()和*(*b1)()是等价的，都是返回值（是个指针）指向地址的值
auto b2 = a2;
cout << b1() << ": " << *b1() << endl;
cout << (*b2)() << ": " << *(*b2)() << endl;
int*(*c[3])(void) = { a1,a2,a3 }; //创建一个函数指针数组，分别指向a1,a2,a3
//运算符[]的优先级高于*，因此先是一个数组，然后才是指针，所以是一个指针数组。而这个指针数组又是指向函数的，所以是函数指针数组
auto d = c; //c是一个函数指针数组，auto d=c，于是d也是一个同样类型的数组（函数指针数组，且包含3个成员）
int *x_0 = c[0](); //c[0]是函数指针数组的第一个成员，他指向函数a1，因此c[0]后面加上()实际上就是调用a1。函数a1的返回值是一个int指针，所以被赋值给x_0这个指针
int *x_1 = (*d[1])(); //d[1]指向a2，加上*，函数a2被转化为一个指针，*d[1]就是*(a2)，a2被转化为一个指向自己的函数，于是值还是自己。于是(*d[1])相当于a2，然后加上()就相当于调用函数a2
//然后a2函数的返回值（int类型指针）被赋值给x_1
int y_0 = *c[0](); //由于()优先级比*高，因此是先调用函数a1，得到返回值（指针），然后解除指针运算，得到的是返回值指向的地址
int y_1 = *(*d[1])(); //同上
auto m = &c; //m是一个指向（函数指针数组）的指针。
//与上面的d不同，上面的d指针数组被赋值给d，因此d也是一个指针数组。
//这里的m是指针数组的地址被赋值给m，因此m是一个指针（因为地址），他指向的是c这个指针数组。
//因此m（一个指针，指向指针数组的地址）和*m（指针的值——指针数组的地址——指针数组第一个成员的地址），c指针数组（通常被转化为指向这个指针数组的指针）
//&m表示为m指针的地址，&(*m)表示指针数组的地址，&c表示指针数组的地址（同第一个成员的地址），&c[0]指针数组第一个成员的地址
cout << &m << endl; //m指针的地址
cout << &(*m) << endl; //指针数组的地址
cout << &c << endl; //指针数组的地址
cout << &c[0] << endl; //指针数组第一个成员的地址，同上面
cout << endl;
cout << m << endl; //指针（表示为指针指向的地址——指针数组的地址）
cout << *m << endl; //指针的值（指向地址的值——是函数指针数组，又通常被转化为指向他本身的指针，因此同m）
cout << c << endl; //指针数组，通常被转化为指向他的指针。c[0]同c
cout << endl;
int*(*(*n)[3])(void) = &c; //n的类型同m
//首先把(*n)看做一个整体，*(*n)[3]中，(*n)这个整体是一个指针数组（包含3个元素的），而n是一个指针，这个指针指向这个整体的指针数组。
//注意对比：int*(*c[3])(void) = { a1,a2,a3 };
//因为n这个指针指向整体的这个指针数组，所以他的值是&c，c是这个指针数组整体的地址
//因为n指向c这个指针数组，所以*n就是指针数组（因为n指向它），因此(*n)[1]就是这个指针数组的第二个成员c[1]（指向函数a2）
cout << (*n)[1] << "和" << a2 << endl;
system("pause");
return 0;
}
int* a1(void)
{
static int a = 1;
int*m = &a;
return m;
}
int* a2(void)
{
static int a = 2;
int*m = &a;
return m;
}
int* a3(void)
{
static int a = 3;
int*m = &a;
return m;
}
输出：
0087B034: 1 0087B038: 2 0039FE38 0039FE80 0039FE80 0039FE80 0039FE80 0039FE80 0039FE80 008713F2和008713F2 请按任意键继续. . .
解释：
①正如代码前面红字绿字所说，无论是函数、字符串、数组或者其他什么的，他们的名字，并不是地址，只是大多数情况下，被转化为指向他自己的指针。因此，假如函数名字是abc，那么abc、*abc（指向自己的指针的值，还是自己），**abc等，都是函数的地址（因为被转化为指向他自己的指针了）。
②&是显示他的地址。例如&函数名，显示的是函数名的地址，因此，函数a1和函数&a1（代码中没有展现），他们的值是相同的，只不过a1是通过指向他的指针（a1的地址）所展现，而&a1就是输出函数a1的地址。
③指针数组的声明方式是
int*指针数组名[成员个数] = {第一个成员指向的地址, 第二个成员指向的地址, ……}
而
int *指针名=数组名;
是一个指向数组的指针——他解除运算后，就不是指针了。
举个简单例子，如代码：
int a[3] = { 1,2,3 };
int*b[3] = { &a[0],&a[1],&a[2] };
int*c = a;
cout << *c[0] << endl; //编译器会提示c[0]不是指针
cout << *b[0] << endl;
//但这个b[0]就没问题
c[0]能显示a[0]值的原因在于，c是一个int类型的指针，他指向a[3]这个数组，相当于指向a[3]这个数组的第一个成员，因此c输出的是数组第一个成员的地址。
而c[0]则输出的是这个地址的值（[0]有点类似*c），c[1]则是输出这个地址往右偏移一个int距离的地址的值。同理，b[0][0]和*b[0]展现出来的值是一样的。
是不是这个原因不确定，但是结果根据观测，是确定的。
这个代码，其中指针数组b[0]，b[1]，b[2]分别指向不同的数组a的成员的地址，但不代表其是连续的，即b[2]-b[1]不一定等于b[1]-b[0]，因为是三个指针分别赋值（指向不同的地址）。
而c[0],c[1]是连续的，因为相当于偏移了一个int的内存地址距离。因此c[3]指向的是a[2]后面一个int距离的内存地址（输出的是这个地址的值），而b[3]由于没有声明和初始化，所以b[3]是不确定的（并不一定在b[2]后面一个int距离的内存地址）。
使用typedef进行简化：
之前有说过，typedef可以用一个别名替代原名：
例如： typedef 原名 别名;
在某些情况下，可以极大的简化输入。
例如上面，我们要表示一个函数指针，需要例如：
int *(*函数指针)(void); 这样
如果使用typedef，则可以简化，如：
typedef int*(*abc)(void);
这个时候，abc就表示是函数指针，例如abc x_1，表示，x_1是一个函数指针。
如代码：
#include<iostream>
using namespace std;
typedef int *(*abc)(void); //使用abc，让abc表示函数指针
//另，好像不能用typedef的别名来代替函数原型和函数头
int* a_1(void); //a_1函数
int main()
{
abc m1 = a_1; //m1指向函数a_1
cout << *m1() << endl; //m1()调用函数a_1（得到返回值，是一个指针），加*则解除指针，输出值
system("pause");
return 0;
}
int* a_1(void)
{
int a = 10;
int *b = &a;
return b;
}
输出：
10 请按任意键继续. . .
总结：
①个人推测：假如使用typedef，将例如abc之类的代码，放在原本应该是这个类型的名字（函数名、字符串名、变量名等）之类的位置。那么这个例如是abc的代码，就是该类型的别名，
使用方法是：abc之类的代码 def之类名字
就是指def是abc所表示的类型。
如上面代码中，abc表示是函数指针的别名，则abc m1也是函数指针。
②指针数组也可以用typedef来使用别名。例如代码：
typedef int *(*abc[2])(void);
//使用abc来作为此类指针数组的别名
abc m = { a_1,a_2 };
//m这个指针数组分别指向函数a_1和函数a_2