超详细的函数指针

函数指针基础

使用函数指针一般要实现：
1）获取函数地址
2）声明函数指针
3）使用函数指针调用函数

（1）获取函数地址:直接使用函数名（函数名就是地址），比如调用think（）函数：
                      show_array(think);
          
（2）声明函数指针
	               int sum(int n);  //（1式）  
	               int (*p)(int n); //（2式）
	               p=sum;

	2式中  (*p) 必须加括号，(*p)相当于1式中的sum，那么p就是指向sum;
	否则，p函数返回的是一个指针。

（3）调用函数
   接着（2）中的示例：
                 int x=sum(2);
                 int x=(*p)(2);//这两句话是一样的！

深入探讨函数指针

int arr[3] = { 6, 2, 1 };

//三个函数声明（返回类型和参数形式都是一样的）：
const int *f1(const int arr[],int n);
const int *f2(const int *arr,int n);
const int *f3(const int arr[],int n);

const int* f1(const int arr[], int n)
{
	return arr;
}
const int *f2(const int*arr, int n)
{
	return arr + 1;
}
const int *f3(const int arr[], int n)
{
	return arr + 2;
}

//声明一个指向f1()的指针
/*圈圈准则（自创勿喷）
1）把const int *f1(const int arr[],int n);看成：
   圈圈  f1 圈圈 
   只留下f1，其他全部看成圈圈
 2）p1指向f1
    所以 圈圈 *p1圈圈 = f1;就是声明
 */
const int *(*p1)(const int arr[],int n)=f1;
//感觉头大的话可以用：
auto p2=f1;
cout << "Address      Values" << endl;
//下面第一行中的(*p1)也可以只写成p1比如第二行
cout << (*p1)(arr, 3) << "      " << *(*p1)(arr, 3) << endl;
cout << (p1)(arr, 3) << "      " << *(p1)(arr, 3) << endl;
cout << p2(arr, 3) << "      " << *p2(arr, 3) << endl;

运行如下：

//接下来我们使用指针数组,数组中元素分别指向f1,f2,f3这三个函数
/*
  依然圈圈准则
  pa是个指针数组 所以 *pa[3]表明，pa是个指针数组
  加上圈圈 后(注意优先级)：圈圈 （*pa[3]）圈圈 = {f1,f2,f3};
 */
const int *(*pa[3])(const int arr[],int n)={f1,f2,f3};
//看着是不是有点麻烦，那么简单一点来
auto pb = pa;
cout << "使用指针数组" << endl;
cout << "Address      Values" << endl;
cout << (pa[0])(arr, 3) << "      " << *(pa[0])(arr, 3) << endl;
cout << (pa[1])(arr, 3) << "      " << *(pa[1])(arr, 3) << endl;
cout << (pa[2])(arr, 3) << "      " << *(pa[2])(arr, 3) << endl;
cout << "使用一个指向指针数组首元素的指针" << endl;
cout << "Address      Values" << endl;
cout << (pa[0])(arr, 3) << "      " << *(pa[0])(arr, 3) << endl;
cout << (pa[1])(arr, 3) << "      " << *(pa[1])(arr, 3) << endl;
cout << (pa[2])(arr, 3) << "      " << *(pa[2])(arr, 3) << endl;

下面图中的“数组指针”全部改为“指针数组”

//接下来我们再增加一下难度，设一个指向pa的指针
//首先，觉得头大，先用简单方法
auto pc = &pa;
//但是我们可以挣扎一下，不妨去试一试嘛,转转你的小脑瓜：圈圈准则
/*
pd指向pa，那么(*pd)表明pd是个指针，我们利用圈圈准则，把pa声明分解
 外圈圈        （内圈圈pa内圈圈） 外圈圈
 const int*   (*     pa [3] ) (const int arr[],int n)
 所以我们结合圈圈准则和优先级原则将pa换成 (*pd),再加上圈圈就可以了
 外圈圈        (内圈圈 (*pd)内圈圈)外圈圈
 */
 const int *(*(*pd)[3])(const int arr[],int n)=&pa;

//另一个问题又来了，既然声明了，那么我们如何来调用呢？
/*
 1）调用的时候，我这儿有个方法，先看pd，即函数名（不是函数指针就先看变量名）
 2）pd指向pa   ==》  *pd就相当于 pa
 3）我们在表示pa的元素时，查看f1，就是  pa[0](arr,10);
       <<=====>>   （*pd）[0](arr,10)
     同理，查看pa[0]对应的值，就是(*pa[0])(arr,10)
       <<=====>>   (*(*pd)[0]) (arr,10) 
 */
cout << "Address      Values" << endl;
cout << (*pd)[0](arr, 3) << "      "<<*(*pd)[0](arr, 3) << endl;
cout << (*pd)[1](arr, 3) << "      "<<*(*pd)[1](arr, 3) << endl;