在前期的文章中，我们已经学习完了指针初阶的内容，这期我们开始学习指针的进阶部分。

指针初阶文章入口：指针初阶

重点知识概览

前期回顾

重点知识概览

指针进阶部分的全部重点内容：

1. 字符指针
2. 数组指针
3. 指针数组
4. 数组传参和指针传参
5. 函数指针
6. 函数指针数组
7. 指向函数指针数组的指针
8. 回调函数
9. 指针和数组面试题的

这些内容我们大概会有3~4篇文章来完成，欢迎大家的点赞与收藏。

前期回顾

指针的由来：

在计算机内存中会划分一个个的内存单元，每个内存单元都有一个独立的编号，这些编号也被称为地址，地址在C语言中被称为指针。指针（地址）需要存储到变量中，这个变量就被称为指针变量。

我们在初级阶段的《指针》章节已经接触过了，我们知道了指针的概念：

1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。

3. 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。

4. 指针的运算。

这个章节，我们继续探讨指针的高级主题。

字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* ;

一般使用:

代码 const char* p = " abcdef " ; 特别容易让同学以为是把字符串 abcdef 放到字符指针 p 里了，但是本质是把字符串 abcdef 首字符的地址放到了p中。

上面代码的意思是把一个常量字符串的首字符 a 的地址存放到指针变量 p 中。

下面有一道笔试题：

#include <stdio.h>
int main()
{
	char str1[] = "hello world.";
	char str2[] = "hello world.";
	const char* str3 = "hello world.";
	const char* str4 = "hello world.";
	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");

	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");

	return 0;
}

这里最终输出的是：

原因：

这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

指针数组

在《指针》章节我们也学了指针数组，指针数组是一个存放指针的数组。这里我们再复习一下，下面指针数组是什么意思？

可以使用类比的方法来记忆：

整形数组——存放整形的数组
字符数组——存放字符的数组
指针数组——存放指针的数组

使用指针数组模拟实现二维数组：

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };

	int* arr[] = { arr1,arr2,arr3 };

	int i = 0, j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
			//printf("%d ", *(arr[i] + j));
			//printf("%d ", *(*(arr + i) + j));
			//三种方法打印的效果相同
		}
		printf("\n");
	}

	return 0;
}

打印结果：

数组指针

数组指针的定义

数组指针是指针？还是数组？答案是：指针。

我们已经熟悉：

整形指针——指向整形变量的指针，存放整形变量地址的指针变量。
字符指针——指向字符变量的指针，存放字符变量地址的指针变量。
数组指针——指向数组的指针，存放的是数组的地址。

下面代码哪个是数组指针？

int (*p)[10]是数组指针。

&数组名VS数组名

数组名的理解：

数组名是数组首元素的地址：

虽然数组名是数组首元素的地址，但是存在两个例外：

1.sizeof(数组)名，这里的数组名不是数组首元素的地址，这里的数组名表示的是整个数组， sizeof(数组)名计算的是整个数组的大小，单位是字节。

2.&数组名，这里的数组依然表示整个数组，&数组名取出的是整个数组的地址。

除此之外，其他地方所有的数组名都是数组首元素的地址。

为了能让大家看出上面代码中arr，&arr[0]，&arr的区别，我们可以使用下面的方法：

1.在VS编译器中进行调试时，使用监视窗口观察类型：

2.不同类型指针加1移动的步长会有所不同：

对于数组名来说，&数组名得到的是整个数组的地址

数组指针的使用

那数组指针是怎么使用的呢？既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。看代码：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int(*p)[10] = &arr;  //*&arr==arr
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *((*p) + i));
		//printf("%d ", (*p)[i]); 两种方法都可以打印数组
	}
	return 0;
}

我们在实际应用中，很少会使用这种方式来写代码。那么数组指针怎么试着用呢？一般在二维数组上才方便。

我们平时调用函数使用二维数组进行传参时，一般使用形参是指针的形式：

//常规方法——二维数组传参，形参是二维数组
void Print(int arr[3][5], int r, int c)
{
	int i = 0, j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,  2,3,4,5,6,  3,4,5,6,7 };
	Print(arr, 3, 5);//常规方法
	return 0;
}

而今天，我们可以使用指针的形式进行传参：

//二维数组传参——形参是指针的形式
void Print2(int(*p)[5], int r, int c)
{
	int i = 0, j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
			//printf("%d ", p[i][j]);
		}
		printf("\n");
	}
}

int main()
{
	int arr[3][5] = { 1,2,3,4,5,  2,3,4,5,6,  3,4,5,6,7 };
	//Print1(arr, 3, 5);//常规方法
	Print2(arr, 3, 5);
	return 0;
}

总结：一维数组传参，形参部分可以是数组，也可以是指针。

//形参是数组的形式
void test1(int arr[],int sz)
{}
//形参是指针的形式
void test2(int *p,int sz)
{}
int main()
{
	int arr[5] = { 0 };
	test1(arr, 5);
	test2(arr, 5);
	return 0;
}

二维数组传参，形参部分可以是数组，也可以是指针

//形参是数组
void test3(char arr[3][5],int r,int c)
{}
//形参是指针
void test4(char(*p)[5], int r, int c)
{}
int main()
{
	char arr[3][5] = { 0 };
	test3(arr, 3, 5);
	test4(arr, 3, 5);
	return 0;
}

数组参数和指针参数

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

一维数组传参

判断下列函数设计的是否正确：

#include <stdio.h>
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);
}

二维数组传参

判断下列函数设计的是否正确：

void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
void test(int* arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int(*arr)[5])//ok？
{}
void test(int** arr)//ok？
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}