函数指针与指针函数

指针函数

  指针函数顾名思义，本质上是一个函数，不过它的返回值是一个指针。其声明的形式如下所示：

ret *func(args,...);

  其中func表示函数；args表示形参列表；ret *作为一个整体，表示func函数的返回值，是一个指针类型。
  实列说明如下：

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

int* func_sum(int n)
{
	if (n<0)
	{
		printf("error:n must be >0\n");
		exit(-1);
	}
	static int sum = 0u;//此时sum是静态局部变量
	int* p = &sum;
	int i = 0u;
	for (i = 0; i < n+1; i++)
	{
		sum = sum + i;
	}
	return p;
}

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

  上例中，int *func_sum(int n)就是一个指针函数，函数功能是计算从0到n所有自然数之和，结果通过指针返回给调用方。
  代码运行结果如下所示：

  在此例中，使用了关键字static修饰了变量sum，为什么要这么做呢？下面我们不使用static修饰变量，看看结果会有什么不一样：

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

int* func_sum(int n)
{
	if (n<0)
	{
		printf("error:n must be >0\n");
		exit(-1);
	}
	int sum = 0u;//此时sum是局部变量
	int* p = &sum;
	int i = 0u;
	for (i = 0; i < n+1; i++)
	{
		sum = sum + i;
	}
	return p;
}

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

  执行结果如下，发现仍能得到正确结果。

  可是如果我们把main函数里面稍微改动一下，如下所示：

void main(void)
{
	int num = 0u;
	printf("please input your number:\n");
	scanf_s("%d", &num);
	int* p = func_sum(num);
	printf("please wait for a while...\n");//插入此行代码
	printf("sum = %d\n", *p);
}

  运行结果如下所示：

  为什么会出现这种结果呢？
  原因在于，一般的局部变量是存放于栈区的，当函数结束后，栈区的变量就会释放掉。如果我们在函数中定义一个局部变量，再使用一个指针去指向这个变量，当函数调用结束后，这个变量的空间就已经被释放，此时就算返回该地址的指针，也不一定会返回正确的值。上面的示例中，在返回该指针后，立即访问确实得到了正确结果，但这只是一种巧合的情况，可能等一会再去访问，该地址可能已经被其他变量占用以至于得到的不是我们想要的结果，甚至更严重的，可能会访问到不该访问的地址造成段错误从而导致程序崩溃。
  而使用static去修饰变量，那么该变量就变成了静态局部变量。静态局部变量存放于数据段中，它的生命周期存在于整个程序运行期间，只要程序没结束，该变量就会一直存在，所以指针就能一直访问到该变量。当然，也可以使用全局变量，全局变量也存放于数据段中。

函数指针

  函数指针的本质是一个指针，该指针的地址指向了一个函数，所以它是指向函数的指针。
  函数的定义存于代码段，因此每个函数在代码段中，都有自己的入口地址，函数指针就是指向代码段中函数入口地址的指针。

函数指针声明

  声明形式如下：

ret (*func)(args,...)

  其中，ret为返回值；*func作为一个整体，代表的是指向该函数的指针；args表示形参列表。其中func被称为函数指针变量。
  实例如下：

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

int (*fun)(int, int);//函数指针的定义

int add(int a, int b)
{
	int result;
	result = a + b;
	return result;
}

void main(void)
{
	int result1;
	fun = add;
	result1 = fun(2, 3);//函数指针的调用方法1
	//result1 = (*add)(2, 3);//函数指针的调用方法2
	//result1 = (*fun)(2, 3);//函数指针的调用方法3
	printf("result1 = %d\n", result1);
}

  执行结果如下：

  在调用时，既可以直接使用函数指针调用，也可以通过函数指针所指向的值调用。(*fun)所代表的就是函数指针所指向的值，也就是函数本身。

函数指针与typedef

  实例如下：

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

typedef int (*fun)(int, int);

int add(int a, int b)
{
	int result;
	result = a + b;
	return result;
}

int multiply(int a, int b)
{
	int result;
	result = a * b;
	return result;
}

void main(void)
{
	int result1,result2;
	fun test1 = add;
	fun test2 = multiply;

	result1 = test1(2, 3);
	result2 = test2(2, 3);

	printf("result1 = %d\n", result1);
	printf("result2 = %d\n", result2);
}

  执行结果如下：

  typedef的用法是给一个存在的类型取一个别名，上面的例子中fun被定义为了一个函数的类型，被fun修饰得test1和test2即为一个函数，有两个int类型的形参，返回一个int类型。

函数指针与struct

  实例如下：

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


struct fun{
	int (*test_add)(int a, int b);
	int (*test_multiply)(int a, int b);
};
int add(int a, int b)
{
	int result;
	result = a + b;
	return result;
}

int multiply(int a, int b)
{
	int result;
	result = a * b;
	return result;
}

struct fun func = {
	.test_add = add,
	.test_multiply = multiply,
};


void main(void)
{
	int result1,result2;

	result1 = func.test_add(2, 3);
	result2 = func.test_multiply(2, 3);

	printf("result1 = %d\n", result1);
	printf("result2 = %d\n", result2);
}

  执行结果如下：

为什么要使用函数指针？

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

回调函数

  函数指针的一个非常典型的应用就是回调函数。
  回调函数就是一个通过函数指针调用的函数。其将函数指针作为一个参数，传递给另一个函数。回调函数并不是由实现方直接调用，而是在特定的事件或条件发生时由另外一方来调用的。
  实例如下：

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

int func_sum(int n)
{
	if (n < 0)
	{
		printf("error:n must be >0\n");
		exit(-1);
	}
	int sum = 0u;//此时sum是局部变量
	int i = 0u;
	for (i = 0; i < n + 1; i++)
	{
		sum = sum + i;
	}
	return sum;
}

int callback(int n, int (*p)(int))
{
	return p(n);
}

void main(void)
{
	int num = 0u;
	printf("please input your number:\n");
	scanf_s("%d", &num);
	int* p = func_sum(num);
	printf("sum = %d\n", callback(num,func_sum));
}

  执行结果如下：

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