指针数组与数组指针、函数指针与函数指针数组

一、指针数组

是一个存放指针的数组。

eg：

int *arr[];//[]优先级高，所以arr首先是一个数组，里面存放的是一个个指针

int** arr[];//数组中放入二级指针

二、数组指针

是一个指向数组的指针。

eg：

int (*arr)[10];//指向int[10]的指针

解释：arr先和*结合，说明arr是一个指针变量量，然后指针指向的是一个大小为10个整型

的数组。所以arr是一个指针，指向一个数组，叫数组指针
那么，数组的地址应该如何存放呢？

int arr[10] = {0};
int*p1 = &arr;
int (*p2)[10] = &arr;

看上面两种存放方式，显然，选择p2比较合适，因为p2是数组指针。

三、数组与指针传参

我们知道数组传参时，会发生降级现象，会降级为指针，

一维数组传参：

测试以下函数：

void test(int arr[])//OK
{}
void test(int arr[10])//OK
{}
void test(int *arr)//OK
{}
void test2(int *arr[20])//OK
{}
void test2(int **arr)//OK
{}
int main()
{
	int arr[10] = { 0 };//一维数组
	int *arr2[20] = { 0 };//一维指针数组
	test(arr);
	test2(arr2);
        system("pause");
	return 0;
}

一维数组会降级为一维指针，一维数组在传参时，形参可以为一维数组、一级指针、一维指针数组和二级指针。

二维数组传参：

测试以下函数：

void test(int arr[3][5])//ok
{}
void test(int arr[][])//not ok：“arr”: 缺少下标
{}
void test(int arr[][5])//ok
{}
void test(int *arr)//not ok：“函数”:“int *”与“int [3][5]”的间接级别不同
{}
void test(int* arr[5])//not ok：“int **”与“int [3][5]”的间接级别不同
{}
void test(int (*arr)[5])//ok
{}
void test(int **arr)//not ok：“int **”与“int [3][5]”的间接级别不同
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}

二维数组传参时会降级为数组指针，形参可以为数组指针和二维数组。

一级指针传参：

测试以下函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<Windows.h>

void print(int *p, int sz)
{
	int i = 0;
	for (i = 0; i<sz;i++)
	{
		printf("%d\n", *(p + i));
	}
}
int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	int *p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针p，传给函数
	print(p, sz);
	system("pause");
	return 0;
}

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
答：一级指针

二级指针传参：

运行以下代码：

void test(char **p)
{ }
int main()
{
char c = 'b';
char*pc = &c;
char**ppc = &pc;
char* arr[10];
test(&pc);
test(ppc);
test(arr);
return 0;
} 

当函数的参数为二级指针的时候，可以接收什么参数？
答：函数参数为二级指针，可以接受指针数组、二级指针、一级指针类型的参数。

四、函数指针
我们先来认识以下，什么叫函数指针？阅读以下代码，哪个可以保存函数地址？

void test()
{
printf("hehe\n");
}
//下面pfun1和pfun2哪个有能存放test函数的地址？
void (*pfun1)();
void *pfun2();

首先，我们知道能保存地址的是指针；那么问题就转化为了哪个是指针的问题？同数组指针一样，我们考虑优先级的问题：pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。所以pfun1可以保存函数地址。而“void *pfun2();”是一个函数声明，返回值为void*类型。
如何用函数指针调用函数呢？
(*指针名)();
(指针名)();

五、函数指针数组
类似于指针数组，要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？ 以下三种方式，那种是呢？
int (*parr1[10]])();//parr1先与[]结合，说明它是一个数组，数组的内容是 int (*)() 类型的函数指针。
int *parr2[10]();//parr2先与*结合，说明它是一个指针
int (*)() parr3[10];//没有这种定义方式，是错误的
所以，第一种是函数指针数组的正确定义方式。

以下是函数指针数组的一个应用：（计算器）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<Windows.h>

int _add(int x, int y)
{
	return x + y;
}
int _sub(int x, int y)
{
	return x - y;
}
int _mul(int x, int y)
{
	return x*y;
}
int _div(int x, int y)
{
	return x / y;
}
void menu()
{
	printf("***********************************\n");
	printf("*****1 add               2 sub*****\n");
	printf("*****3 mul               4 div*****\n");
	printf("***********************************\n");
}
int main()
{
	int input = 1;
	int x, y;
	int(*cal[])(int x, int y) = { 0, _add, _sub, _mul, _div };
	char ch[] = { '+', '-', '*', '/' };
	while (input)
	{
		menu();
		printf("please select:");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("please enter two integers:");
			scanf("%d %d", &x, &y);
			int result = (*cal[input])(x, y);
			printf("%d%c%d=%d\n", x, ch[input - 1], y, result);
		}
		else
			continue;
	}
	system("pause");
	return 0;
}

六、函数指针数组的指针
指向函数指针数组的指针是一个 指针，指针指向一个 数组 ，数组的元素都是 函数指针 ;
那么如何定义呢？
答：
类似于指针数组的指针：int *(*arr)[];
函数指针数组的指针：int ( *(*parr)[]) ();

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

 
 

  
  

 
 
 
 

  
  
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<Windows.h>
int _cmp(void* str1,void* str2)
{
	return (*(int *)str1 > *(int *)str2);
}
void exchange(void* str1, void* str2, int sz_type)
{
	int i = 0;
	for (i = 0; i < sz_type; i++)
	{
		char tmp = *((char*)str1+i);
		*((char*)str1+i) = *((char*)str2+i);
		*((char*)str2 + i) = tmp;
	}
}
void bubble_sort(void* dest, int count, int sz_type, int _cmp(void*, void *))
{
	int i = 0;
	char* ret = (char*)dest;
	int flag = 0;
	int k = 0;
	for (k = 0; k < count - 1; k++)
	{
		for (i = 0; i < count - 1 - k; i++)
		{
			if (_cmp(ret + sz_type*i, ret + sz_type*(i+1))>0)
			{
				exchange(ret + sz_type*i, ret + sz_type*(i + 1), sz_type);
				flag = 1;
			}
		}
		if (flag == 0)
			break;
	}
}
int main()
{
	int dest[] = { 0, 43, 24, 0,9, 78 };
	int count = sizeof(dest) / sizeof(dest[0]);
	bubble_sort(dest, count, sizeof(int), _cmp);
	int i = 0;
	for (i = 0; i < count;i++)
	    printf("%d ", dest[i]);
	printf("\n");
	system("pause");
	return 0;
}