C语言指针深造及回调函数总结

 一、数组指针

      概述：数组指针是指针，简单来说数组可以当做修饰语，修饰指针，只不过它是一个指向数组的指针。

      举例：int *p[100];表示指针数组（https://blog.csdn.net/Sun_student/article/details/83932242）这里有指针数组的概念，

                 int (*p)[100];表示数组指针，指向int型数组的指针。

                 帮助理解：*符号的优先级比[ ]符号的优先级低，所以表示数组指针的时候记得给指针加()。

      怎么使用数组指针？

             数组指针是指向数组的指针，那么它就存储的是数组的地址。

             举例：          

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

void print_arr1(int arr[3][5], int row, int col) 
{
    int i = 0;
    int j = 0;
    for(i=0; i<row; i++)
    {
        for(j=0; j<col; j++)
	{
	    printf("%d ", arr[i][j]);
	} 
	printf("\n");
    }
}

void print_arr2(int (*arr)[5], int row, int col)
{ 
    int i = 0;
    int j = 0;
    for (i = 0; i<row; i++)
    { 
	for (j = 0; j<col; j++)
	{ 
	    printf("%d ", arr[i][j]);
	}
	printf("\n");
    } 
}

int main()
{
    int arr[3][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    print_arr1(arr, 3, 5);
    printf("-----------\n");
    //数组名arr，表示首元素的地址    
    //但是二维数组的首元素是二维数组的第一行    
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址    
    //可以数组指针来接收    
    print_arr2(arr, 3, 5); 
    system("pause");
    return 0;
}

        从代码中可以看出int arr[3][5]等价于int (*arr)[5]，传递的参数是一个二维数组，二维数组的第一个元素相当于一个一位数组，那么接受这个一位数组的地址就可以使用一个数组指针来接收。

        注意：二维数组传递参数，第二个[ ]里必须声明参数的值，不然编译器不知道二维数组里每一个一位数组值的个数是多少，会报错。

二、函数指针

      简单概述：函数也有地址，那么就可以通过指针进行解引用，即就是函数指针。

      其实函数指针不经常使用，但是我们还是要理解函数指针，看两个代码：

              1.(*(void (*)())0)();    2.void (*signal(int, void(*)(int)))(int);

      理解思路：小编个人喜欢从里往外分析，也可以从外往里分析。

              1.先看(*)()表示一个函数指针，定义一个*p指针变量，这里小编假设默认p的初始化为0（这里的代价就是多声明了一个“哑”变量），所以(*0)()可以表示为(*)()；再来看void (*)()表示返回值为void型的指针类型；再分析(void (*)())0 ：0表示量，对常量前面加类型表示强制类型转换，那么就可以定义一个变量fp，令fp表示(void (*)())0 ；最后(*(void (*)())0)()表示(*fp)(),这不就是一个函数指针么。所以(*(void (*)())0)()表示一个函数指针，只不过这个函数指针是一个返回值为void的函数的指针类型。

              2.先来了解signal函数：函数中第一个参数是一个整型的信号编号，第二个参数是一个指向调用前的用户定义信号处理函数的指针；这个小编采用从外往里分析：void函数，void函数里面是一个signal函数，只不过这个函数的返回值是一个指针类型，所以void (*signal(int, void(*)(int)))(int)是函数指针，只不过这个函数指针是一个void型，返回值为指针类型。

三、函数指针数组

      简单概述：简单来说就是一个数组，只不过每个元素都是一个函数指针的地址，通过对地址的解引用来调用数组里面的函数。

      用途：转移表，举例：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.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 dvi(int a, int b)
{
	return a / b;
}

int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int (*p[5])(int x, int y) = { 0, add, sub, mul, dvi };//转移表
	while (input)
	{
		printf("==================\n");
		printf(" 1:add      2:sub \n");
		printf(" 3.mul      4:div \n");
		printf("==================\n");
		printf("请输入：");
		scanf("%d", &input);
		if ((input <= 4) && (input >= 1))
		{
			printf("请输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
		}
		else
		{
			printf("输入有误\n");
		}
		printf("ret = %d\n", ret);
	}
	system("pause");
	return 0;
}

       强调：函数名的地址就是函数所在的首地址。

四、指向函数指针数组的指针

     简单概述：很明显是一个指针，只不过是一个指向函数指针的数组，数组里面的元素为函数指针。

     那怎么定义一个这样的指针：先定义一个函数指针void(*pfun)()，根据函数指针再用定一个函数指针数组void(*pfunarr[100])()，从而表示出void(*(*ppfunarr)[100])(),那么ppfunarr就是一个指向函数指针数组pfunarr的指针。

五、回调函数

                      

     根据上图分析：qsort是实现排序的函数，其中有四个变量：1.数组；2.数组的元素个数；3.数组类型的大小；4.比较函数。

六、练习题

      指针：1.例题

                         

                  代码实现：

                      

                  2.例题

                        

                   代码实现：

                       

      qsort的各类型排序：

              1.char整型代码：

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

//实现qsort的整型排序

int int_cmp(const void* p1, const void* p2)
{
	return (*(char*)p1 - *(char*)p2);
}

int main()
{
	char arr[] = { 'a', 'd', 'c', 'b', 'e' };
	int len = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, len, sizeof(char), char_cmp);
	for (int i = 0; i < len; ++i)
	{
		printf("%c", arr[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}

              2.int字符型：

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

//实现qsort的整型排序

int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}

int main()
{
	int arr[] = { 5, 3, 2, 0, 4, 6, 8, 9, 7, 1 };
	int len = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, len, sizeof(int), int_cmp);
	for (int i = 0; i < len; ++i)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}

      模仿qsort实现一个通用的冒泡排序：

            代码实现：

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

//使用qsort模拟实现一个通用的冒泡排序

int cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}

void Bubble(int* arr, int len)
{
	int count = len;
	while (count != 1)
	{
		for (int i = 0; i < len - 1; ++i)
		{
			if (cmp(&arr[i], &arr[i+1]) < 0)
			{
				int tmp = arr[i];
				arr[i] = arr[i + 1];
				arr[i + 1] = tmp;
			}
		}
		--count;
	}
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main()
{
	int arr[] = { 5, 0, 2 };
	int len = sizeof(arr) / sizeof(arr[0]);
	Bubble(arr, len);
	system("pause");
	return 0;
}