【C语言】指针进阶（指针数组、数组指针，函数指针、指向函数指针数组的指针、回调函数etc）

1.指针数组：存放指针的数组。

eg: int* a[4];a数组有4个元素，每个元素存放整型指针。

2.数组指针：存放数组地址的指针。

eg：    int arr[4];
            int (*p)[4] = &arr;

         p先与*结合，说明p是一个指针变量，然后指针指向一个大小为4个整数的数组，所以p是一个指针，指向一个数组，叫指针数组。

int main()
{
	int arr[3][4] = { 1, 2, 3, 4, 5, 6 ,7,8,9,10,11,12};
	int i = 0;
	int j = 0;
	int  (*p)[4] = arr;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%d ", *(*(p + i)+j));
		}
	}
	system("pause");
	return 0;
}

执行结果为：

 

p为数组指针，指向数组的元素为4个，每个元素是整型，arr是数组首元素地址，即为第一行地址。

p+i当i=0,1,2时分别表示第一行，第二行，第三行的地址。解引用找到该行，*（p+i）+j表示该行第j个元素，在解引用找到该元素。

4.类型判断

int a[5];                 数组

int *p[10];              指针数组

int  (*p)[10);           数组指针

int （*p[10]）[5];    p【10】有10个元素，每个元素是个地址，该地址能指向一个数组，数组5个元素，每个元素是整型。

                              p是存放数组指针的数组。

5.数组与指针的声明与定义

A

在定义.c定义一个数组，在源.c声明数组

运行结果为：

B

在定义.c定义一个数组，在源.c声明指针，如果按照上面的代码则无法实现，将代码改为如下，则可实现

Why?

Because:声明与定义的是同一块空间，要打印则需要a指向首元素地址，a是指针是4个字节，能只可访问abcd四个字节，a类型为char *,&a为char* *,&a得到首元素地址，打印字符将其强转为char *.

C

在定义.c定义一个指针，在源.c声明数组，按最初的代码将得到一个随机值，因为p为首元素地址，要得到abcdef需要将代码转化如下：

p是首元素地址，（int*）变为整型指针，整型指针解引用访问4个字节，将这4个字节当做整型值，将它作为首元素的地址则char*即可。

6.函数指针

指针变量存放函数地址，书写和数组指针类似如下图：pf为函数指针

void  test()
{
	printf("nv\n");
}
int  main()
{
	int  arr[10];
	int  (*p)[10] = &arr;
	void (*pf)() = &test;//*有无都可以
	(**********pf)();//******摆设
	system("pause");
}

衍生：  函数指针int (*p)(int, int);
             函数指针的数组int(*p[5])(int, int);
             指向函数指针数组的指针int (*(*p[5]))(int, int)=&p;

解释表达式：

(*(void(*)())0）();将0强制类型转化为函数指针类型，0为该函数地址，解引用，调用该函数返回类型void，参数为空

void(*signal(int, void(*(int)))(int);   signal是有两个参数的，一个是int，一个是函数指针类型，该函数指针指向的函数有int类型参数，signal函数的返回类型是一个函数指针，该函数指针指向的函数有一个int参数，返回类型是void类型

计算器的实现

1.普通计算器的实现

void  menu()
{
	printf("***********************************\n");
	printf("***1.Add   2.Sub*******************\n"); 
	printf("***3.Mul   4.Div*******************\n");
	printf("*********0.exit********************\n");
	printf("***********************************\n");
}
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;
}

int  main()
{
	int  input = 0;
	int x = 1;
	int y = 2;
	int ret = 0;
	do
	{
		menu();
		printf("请输入：>");
		scanf_s("%d", &input);
		switch (input)
		{
		case 1:
			ret = Add(x, y);
			printf("ret=%d\n", ret);
			break;
		case 2:
			ret = Sub(x, y);
			printf("ret=%d\n", ret);
			break;
		case 3:
			ret = Mul(x, y);
			printf("ret=%d\n", ret);
			break;
		case 4:
			ret = Div(x, y);
			printf("ret=%d\n", ret);
			break;
		default:
			printf("输入错误");
			break;
		case  0:
			printf("退出");
			break;
		}

	} while (input);
	system("pause");
	return 0;
}

 

2.使用函数指针的数组

void  menu()
{
	printf("***********************************\n");
	printf("***1.Add   2.Sub*******************\n"); 
	printf("***3.Mul   4.Div*******************\n");
	printf("*********0.exit********************\n");
	printf("***********************************\n");
}
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;
}
int  main()
{
	int  input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	int (*p[5])(int,int) = { 0, Add, Sub, Mul, Div };
	
	do
	{
		menu();
		printf("请输入：>");
		scanf_s("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数字：");
			scanf_s("%d%d", &x, &y);
			ret = p[input](x, y);
			printf("ret=%d\n", ret);
		}	
	} while (input);
	return 0;

	system("pause");
}

 

精简版

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   calc(int(*p)(int,int))
{
	int  x = 0;
	int y = 0;
	int  ret = 0;
	printf("请输入两个操作数字：");
	scanf_s("%d%d", &x, &y);
	ret = p(x, y);
	printf("ret=%d\n", ret);

}


void  menu()
{
	printf("***********************************\n");
	printf("***1.Add   2.Sub*******************\n");
	printf("***3.Mul   4.Div*******************\n");
	printf("*********0.exit********************\n");
	printf("***********************************\n");
}
int  main()
{
	int  input = 0;
	int x = 0;
	int y = 0;;
	int(*p[5])(int, int) = { 0, Add, Sub, Mul, Div };

	do
	{
		menu();
		printf("请输入：>");
		scanf_s("%d", &input);
		if (input >= 1 && input <= 4)
		{
			calc(p[input]);
		}

	} while (input);
	return 0;

	system("pause");
}

回调函数

 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另一方调用，用于对该事件或条件进行响应。

 

eg：使用回调函数，模拟实现qsort（采用冒泡的方式）

qsort函数 原型：void  qsort(void  *base,
 size_t  num,
 size_t width,
 int(*cmp)(const  void  *elem1, const  void  *elem2));

qsort函数包含在<stdlib.h>中

qsort函数声明如下：

参数说明：

base,要排序的数组

num,数组中元素的数目

width,每个数组元素占用的内存空间，可使用sizeof函数获得

cmp,指向函数的指针也即函数指针。这个函数用来比较两个数组元素，第一个参数大于，等于，小于第二个参数时，分别显示正值，零，负值。

struct  S
{
	char  name[20];
	int   age;
};

int  cmp_int(const  void*  e1, const  void*e2)
{
	return  *(int*)e1 - *(int *)e2;
}

int   cmp_s_name(const  void*e1, const  void*e2)
{
	return  strcmp(((struct S*)e1)->name, ((struct S*)e2)->name);
}

int   cmp_s_age(const  void*e1, const  void*e2)
{
	return  ((struct S*)e1)->age - ((struct S*)e2)->age;
}

void _Swap(char *buf1, char *buf2, int  width)
{
	
	while (width)
	{
		char  tmp = *buf1;
		*buf1 = *buf2;
	     *buf2 = tmp;
		 buf1++;
		 buf2++;

	}
}

void   bubble_sort(void* base, int  sz, int  width, 
	               int  (*cmp)(const void*e1, const void*e2))
{       
	    int i = 0;
		int j = 0;
		for (i = 0; i < sz - 1; i++)
		{
			for (j = 0; j < sz - 1 - i; j++)
			{
				if (cmp((char *)base+j*width,(char *)base+(j+1)*width)>0)
				{    
					_Swap((char *)base + j*width, (char *)base + (j + 1)*width, width);
				}
	
			}
		}
	
}


int  main()
{
	struct  S  arr[] = { { "zhang", 30 }, { "li", 40 }, { "sladl", 25 } };
	int  sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_s_name);
	system("pause");
	return  0;
}