函数指针，指针函数，回调函数

一、什么是函数指针？

1. 定义

	char* fun1(char* p1, char* p2)         // 1
	char** fun2(char* p1, char* p2);      // 2
	char*(*fun3)(char* p1, char* p2);    // 3   函数指针

1，2，3分别是什么意思呢？

1. 很简单，char*是返回类型，fun1是函数名，括号内是参数
2. 和1相似，char** 是返回类型
3. 就是我们要讲的函数指针，看下面的例子：

	int (*) [10]p    //数组指针

是不是和数组指针特别的相似？这里的fun3不是函数名，是指针变量，它指向一个函数。
函数指针的定义就是，一个指向函数的指针

2. 例子

我们上面定义了一个函数指针，那我们该如何使用它呢？

int Add(int a, int b)
{
	return a + b;
}

int main()
{
	int(*fun1)(int a, int b);       	// 定义函数指针
	fun1 = &Add;
	cout << (*fun1)(1, 2) << endl;		//使用函数指针  （*fun1）
	cout << fun1(1, 2) << endl;			//可以直接使用    fun1

	system("pause");
	return 0;
}

我们在使用指针的时候，需要通过钥匙“ * ”来取其指向的内存的值，函数指针使用也如此。通过用（*fun1）取出该地址的函数然后调用他。也 可以直接使用fun1，因为函数名被编译后其实就是一个地址。

3.（* （void(*)）()0）()

让我们来看看 《C的陷阱与缺陷》中的经典例题

1. void(*)，可以明白这是一个函数指针类型。这个函数没有参数，没有返回型
2. （void(*)()）0,这是将0强制类型转换为函数指针类型，0是一个地址，也就是说函数存在首地址为0的一段区域内。
3. （* （void(*)()）0）这里是取0地址开始的一段内存的内容，其内容就是保存在首地址为0的一段区域的函数
4. （* （ void(*)）()0）() 这里是函数调用

4.函数指针数组

	char* (*fun[3])(char* p);//函数指针数组

它是一个数组，数组名是fun，数组内存了3个指向函数的指针。这些指针指向的一些返回值类型为指向字符的指针，参数为一个指向字符指针的函数。

5.函数指针数组的指针

我一开始看到这东西我脑子里都是？？？，然后查了些博客啥的就弄清楚了。我们都知道什么事数组指针，套用数组指针的理解来理解函数指针数组不就好了吗？

char* (*(*fun)[3]))(char* p);

1.(*fun)，是一个指针。
2.（*fun）[3]，表示这个指针指向一个包含三个元素的数组
3.去掉（* fun）[3]，看上面的例子，char* (* )(char* p)，可以知道数组中的三个元素是返回类型为char*型的，参数为指向字符串的函数。

6.为什么要使用函数指针？

那么，有不少人就觉得，本来很简单的函数调用，搞那么复杂干什么？其实在这样比较简单的代码实现中不容易看出来，当项目比较大，代码变得复杂了以后，函数指针就体现出了其优越性。
举个例子，如果我们要实现数组的排序，我们知道，常用的数组排序方法有很多种，比如快排，插入排序，冒泡排序，选择排序等，如果不管内部实现，你会发现，除了函数名不一样之外，返回值，包括函数入参都是相同的，这时候如果要调用不同的排序方法，就可以使用指针函数来实现，我们只需要修改函数指针初始化的地方，而不需要去修改每个调用的地方（特别是当调用特别频繁的时候）。

二、指针函数

1.指针函数的声明

先看下面的函数声明，注意，此函数有返回值，返回值为int *，即返回值是指针类型的。

int *f(int a, int b);

上面的函数声明又可以写成如下形式：

int* f(int a, int b);    // 让指针标志 * 与int紧贴在一起，而与函数名f间隔开，
							 //这样看起来就明了些了，f是函数名，返回值类型是一个int类型的指针。

指针函数： 顾名思义，它的本质是一个函数，不过它的返回值是一个指针。

2.举例说明

# include <stdio.h>
# include <stdlib.h>

int * func_sum(int n)
{
    if (n < 0)
    {
        printf("error:n must be > 0\n");
        exit(-1);
    }
    static int sum = 0;				// 注意 sum 是用 static int 修饰的
    											// 也可以  int *psum = new int;
    											// 注意如果用new int，记得要释放（delete psum）;
    int *p = &sum;
    for (int i = 0; i < n; i++)
    {
        sum += i;
    }
    return p;
}

int main(void)
{
    int num = 0;
    printf("please input one number:");
    scanf("%d", &num);
    int *p = func_sum(num); 
    printf("sum:%d\n", *p);
    return 0;
}

上例就是一个指针函数的例子，其中，int * func_sum(int n)就是一个指针函数， 其功能十分简单，是根据传入的参数n，来计算从0到n的所有自然数的和，其结果通过指针的形式返回给调用方。
以上代码的运行结果如下所示：

如果我们把指针函数的sum定义为普通的局部变量，会是什么结果呢？不妨来试验一下：（注意这么写是不对的，只为了实验）

# include <stdio.h>
# include <stdlib.h>

int * func_sum(int n)
{
    if (n < 0)
    {
        printf("error:n must be > 0\n");
        exit(-1);
    }
    int sum = 0;								// 这么写是不对的，只为了实验
    int *p = &sum;
    for (int i = 0; i < n; i++)
    {
        sum += i;
    }
    return p;
}

int main(void)
{
    int num = 0;
    printf("please input one number:");
    scanf("%d", &num);
    int *p = func_sum(num); 
    printf("sum:%d\n", *p);
    return 0;
}

执行以上程序，发现仍然能得到正确的结果：(有点小意外)

继续测试，如果我们把main函数里面稍微改动一下，会怎么呢？改动如下：
int main(void)
{
int num = 0;
printf(“please input one number:”);
scanf("%d", &num);
int *p = func_sum(num);
printf(“wait for a while…\n”); //此处加一句打印
printf(“sum:%d\n”, *p); // 隔开了打印*p
return 0;
}
我们在输出sum之前打印一句话，这时看到得到的结果完全不是我们预先想象的样子，得到的并不是我们想要的答案。

为什么会出现上面的结果呢？
其实原因在于，一般的局部变量是存放于栈区的，当函数结束，栈区的变量就会释放掉，如果我们在函数内部定义一个变量，在使用一个指针去指向这个变量，当函数调用结束时，这个变量的空间就已经被释放，这时就算返回了该地址的指针，也不一定会得到正确的值。
上面的示例中，在返回该指针后，立即访问，的确是得到了正确的结果，但这只是十分巧合的情况，如果我们等待一会儿再去访问该地址，很有可能该地址已经被其他的变量所占用，这时候得到的就不是我们想要的结果。甚至更严重的是，如果因此访问到了不可访问的内容，很有可能造成段错误等程序崩溃的情况。

因此，在使用指针函数的时候，一定要必须避免出现返回局部变量指针的情况。

那么为什么用了static就可以避免这个问题呢？
原因是一旦使用了static去修饰变量，那么该变量就变成了静态变量。而静态变量是存放在数据段的，它的生命周期存在于整个程序运行期间，只要程序没有结束，该变量就会一直存在，所以该指针就能一直访问到该变量。
static修饰变量的另一个效果是，如果多个线程同时调用func_sum（），func_sum（）内存段会复制给每个调用的线程，而static int sum却永远是唯一的。那么结果肯定是混乱的（线程不安全的）。这也是因为 静态变量是存放在数据段造成的。

因此，还有一种解决方案是使用全局变量，因为全局变量也是放在数据段的，但是并不推荐使用全局变量。
我认为也可能用 int *psum = new int; 来代替static int sum = 0; 最后返回psum指针。只是外部调用函数后必须记得delete psum ，否则将操作内存泄漏。谨慎！谨慎！

三、回调函数

函数指针的一个非常典型的应用就是回调函数。

1.什么是回调函数？

回调函数就是一个通过指针函数调用的函数。其将函数指针作为一个参数，传递给另一个函数。

回调函数并不是由实现方直接调用，而是在特定的事件或条件发生时由另外一方来调用的。

同样我们来看一个回调函数的例子：

#include<stdio.h>
#include<stdlib.h>

//函数功能：实现累加求和
int func_sum(int n)
{
        int sum = 0;
        if (n < 0)
        {
                printf("n must be > 0\n");
                exit(-1);
        }
        for (int i = 0; i < n; i++)
        {
                sum += i;
        }
        return sum;
}

//这个函数是回调函数，其中第二个参数为一个函数指针，通过该函数指针来调用求和函数，并把结果返回给主调函数
int callback(int n, int (*p)(int))
{
        return p(n);
}

int main(void)
{
        int n = 0;
        printf("please input number:");
        scanf("%d", &n);
        printf("the sum from 0 to %d is %d\n", n, callback(n, func_sum));       //此处直接调用回调函数，而不是直接调用func_sum函数
        return 0;
}

面这个简单的demo就是一个比较典型的回调函数的例子。在这个程序中，回调函数callback无需关心func_sum是怎么实现的，只需要去调用即可。
这样的好处就是，如果以后对求和函数有优化，比如新写了个func_sum2函数的实现，我们只需要在调用回调函数的地方将函数指针指向func_sum2即可，而无需去修改callback函数内部。
以上代码的输出结果如下：

回调函数广泛用于开发场景中，比如信号函数、线程函数等，都使用到了回调函数的知识。