指针数组、回调函数

• 指针 + 二维字符型数组

• char  s[][10] = {"hello", "world", "china"};

        char (*p)[10] = s;    // p 指向二维数组 s  -----  *(*(p+i)+j)  <=>  s[i][j]

        char [10]  s[3];   //此时二维数组的元素是一个一维数组，定义了一个存放字符串的数组

• char *p = "hello";  //p 的类型是 char *  ， char * 的指针变量 p 是一个字符串

        指针数组：存放地址数据的数组

char*  pstr[3] = {"hello", "world", "china"}; // 数组中存放的是字符串的地址   

        pstr[0] ----类型-----> char * 

        &pstr[0] -----类型----> char * *

        -------> char * *p

        ---->   char* *q = pstr; //q 二级指针 

例：对字符串指针数组的冒泡排序

void bubbleSort(char* *p,int len)
{
	int i = 0;
	int j = 0;

	for (i = len-1; i > 0; --i)
	{
		for (j = 0; j < i; ++j)
		{
			if (strcmp(*(p+j),*(p+j+1)) > 0)
			{
				char *t = *(p+j);
				*(p+j) = *(p+j+1);
				*(p+j+1) = t ;
			}
		}
	}
}

• 指针 + 函数

通过 指针 的方式来调用函数，函数名代表函数的入口地址，CPU通过函数名来调用代码。

• eg： int main(int argc, const char *argv[])

        argc ： 命令行参数的个数

        argv ：存放命令行参数的字符串的指针数组

•  eg：  int  add(int a, int b) 

①函数名 ------ 代表函数的入口地址 

②函数名对应的数据类型----> 函数类型：int (int a, int b) -----> 代表返回值为 int 型，有两个 int 型参数的一类函数。

        ------>int  (*p)  (int,int) = add;  // p 指向了add 函数

③调用： int ret = p(1,2);    // int ret = (*p)(1,2);不写 * 是一种简化的、常见的用法，编译器会自动理解这是通过函数指针进行函数调用。

1. 可以定义一个函数类型的指针变量来保留函数的入口地址
2. 有了这个指针变量，就能通过这个指针变量来进行 函数调用。

• 回调函数：callback

通过函数指针调用函数就是回调。C语言使用了函数指针这种方式实现了回调。

例：写一个程序 实现加、减、乘、除，以回调函数的形式，打印对应的结果

#include <stdio.h>

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

int sub(int a,int b)
{
	return a - b;
}
int mul(int a,int b)
{
	return a * b;
}
int div(int a,int b)
{
	return a / b;
}


void processData(int a,int b,int(*p)(int,int))//找准基类型，然后定义它的指针
{
	printf("result: %d\n",p(a,b));
}

int main(int argc, const char *argv[])
{

	processData(1,2,add);
	processData(1,2,sub);
	processData(1,2,mul);
	processData(1,2,div);
	
	return 0;
}

 

为什么通过指针的方式来调用函数？

1. 实现动态调用：在某些情况下，直到程序运行时才能确定要调用哪个函数。通过函数指针，可以根据不同的条件或输入动态地选择要执行的函数，增加了程序的灵活性和可扩展性。
2. 模拟面向对象编程中的多态性：在 C 语言中，虽然没有真正的面向对象特性，但通过函数指针可以在一定程度上模拟多态的行为，使得不同的函数实现可以通过相同的接口（函数指针）被调用。
3. 提高代码的可维护性和可重用性：将函数的调用通过函数指针进行抽象，可以使代码更具模块化，方便对功能进行修改和替换，而不需要修改大量的直接函数调用代码。
4. 优化性能：在一些特定的架构或优化场景中，使用函数指针可能会带来性能上的优势，例如减少分支预测错误等。