C语言进阶——指针进阶

指针的初阶我们可以参看这篇博客

C语言初阶——指针

，这篇博客主要有四个重要结论，也是初阶指针的重要概念：

1.指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
3. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
4. 指针的运算。

下面我们将继续探讨指针的进阶部分

一、字符指针

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

但其实我们很少使用这种方式，而是使用以下这种方式：

int main()
{
    char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
    printf("%s\n", pstr);
    return 0;
}

代码

char* pstr = “hello world.”;

特别容易让我们误以为是把字符串 hello world.放到字符指针 pstr 里，但是本质是把字符串 hello world.首字符的地址放到了pstr中。

总结：
上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。
看一道面试题深入理解

#include 

int main()
{
	char str1[] = "hello bit.";
	char str2[] = "hello bit.";
	char *str3 = "hello bit.";
	char *str4 = "hello bit.";
	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相同。

二、数组指针

学习数组指针前要先搞清楚指针数组和数组指针这两个概念！

2.1 指针数组

指针数组是指针还是数组？

答案：指针数组是数组，是存放指针的数组！

我们都知道如下所示数组

int arr1[5];	//整型数组
char arr2[6];	//字符型数组

那指针数组是什么样的呢？

int* arr3[5];	//是什么？

arr3是一个数组，有五个元素，每个元素是一个整形指针。

2.2 数组指针

同样的问题：数组指针是指针？还是数组？

答案是：数组指针是指针，能够指向数组的指针。

看下面这个例子：p1, p2分别是什么？

int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？

显然刚才已经清楚int *p1[10]是指针数组
那么int (*p2)[10]就是数组指针了，为什么呢？

int (*p)[10];
解释：首先p先和$\ast$结合，说明p是一个指针变量，然后指针p指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。

注意

[]的优先级要高于$\ast$号，所以必须加上（）来保证p先和*结合。

总结
区分数组指针和指针数组，看p先跟谁结合，和*先结合就是数组指针，和[]先结合就是指针数组！

2.3 &数组名VS数组名

对于下面的数组：

int arr[5];

arr和**&arr分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名**到底是啥？
我们看一段代码：

#include 

int main()
{
	int arr[5] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", &arr);
	return 0;
}

结果：

可见数组名和&数组名打印的地址在数值上是一样的。难道两个是一样的吗？
我们再看一段代码：

#include 

int main()
{
	int arr[5] = { 0 };
	printf("arr = %p\n", arr);
	printf("&arr= %p\n", &arr);
	printf("arr+1 = %p\n", arr + 1);
	printf("&arr+1= %p\n", &arr + 1);
	return 0;
}

根据上面的代码我们发现，虽然&arr和arr值是一样的，但是意义应该不一样的。

回顾两个知识点：
数组当中数组名表示数组首元素的地址，两种情况例外：

• sizeof()中单独使用表示整个数组
• 数组名前带&符号表示整个数组

实际上：
&arr 表示的是整个数组的地址，而不是数组首元素的地址。

简单来说就是把数组arr[5]看成一个整体，不区分里面有多少元素，大小即为20（5个int的大小）。数组的地址+1，就是加上整个数组的大小，所以&arr+1 相对于 &arr 的差值是20（5个int的大小）.

再看一段代码可以帮助我们更加深入的理解&arr

可以预见arr与&arr的地址在数值上是相等的，但arr表示数组中首元素的地址，&arr表示的是整个数组的地址。因此arr+1表示加上数组arr[4][5]中一个元素的大小20，即5个int的大小（因为arr[4][5]可以看作4个元素，即每一行是一个元素，每个元素是一个含有5个int大小的数组，这里如果不清楚就要补充一下数组的概念了）；&arr+1则表示加上整个数组的大小80，即$4\ast 5\ast int=80$。

2.4 数组指针的使用

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

#include 
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
    					//但是我们一般很少这样写代码
    return 0;
}

一个数组指针的使用：

#include 
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);
	//数组名arr，表示首元素的地址
	//但是二维数组的首元素是二维数组的第一行
	//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
	//可以数组指针来接收
	print_arr2(arr, 3, 5);
	return 0;
}

数组指针可以帮助我们更好的理解多维数组的传参，但通常我们都使用print_arr1的写法，很少使用print_arr2的写法，因此我们只需弄懂概念即可。
结果：

如果理解了数组指针的概念，再看几个代码：

int arr[5];	//1.
int *parr1[10];	//2.
int (*parr2)[10];	//3.
int (*parr3[10])[5];	//4.

1.整型数组 ；
2.指针数组，parr1先和[]结合所以是数组；
3.数组指针，parr2先和结合所以是指针；
4.数组指针数组，一定要掌握parr3先和谁结合？首先按优先级先看括号里，然后可以发现parr3先和[10]结合所以是数组，其次和结合所以是指针数组，最后和[5]结合所以是数组指针数组！

到这里相信你一定能搞清楚这两者的概念了，如果还有疑惑继续看下面的内容。

三、数组传参和指针传参

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
在进行下面的学习时，我们始终要把握一个准则：

数组传参发生降维，降维成指向其内部元素类型的指针。

3.1 一维数组传参

#include 
void test(int arr[])//1 ok?
{}
void test(int arr[10])//2 ok?
{}
void test(int *arr)//3 ok?
{}
void test2(int *arr[20])//4 ok?
{}
void test2(int **arr)//5 ok?
{}
int main()
{
	int arr[10] = {0};
	int *arr2[20] = {0};
	test(arr);
	test2(arr2);
}

分析

1正确，因为和形参类型相同，[]内的数值可以省略
2正确，同一且[]内的值可以任意值
3正确，想一下上面说的准则，数组传参发生降维，降维成指向其内部元素的类型的指针，arr内部元素的类型为int，降维成指向int类型的指针，不就是int*吗？所以正确
4正确，和传入参数类型相同
5正确，原因同3，arr2是一个指针数组，其内部元素的类型为指针，降维成指向指针的指针，就是二级指针

总结

数组传参发生降维，降维成指向其内部元素类型的指针

到这里，只要牢记准则是不是很容易判断呢？

3.2 二维数组传参

二维数组相比于一维数组会更复杂些，但只要牢记准则其实并不难

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

首先二维数组可以看为一维数组，只不过每个元素是一个数组
arr[3][5]是一个二维数组，有15个int，从二维数组角度看，有3个元素，每个元素有5个int，且每个元素是一个数组。

分析如下：

1 正确，类型相同不用解释了
2 错误，二维数组传参，函数参数设计智能省略第一个[ ]的数字
3 正确，可以省略第一个[ ]的数字
4 错误，前面说了数组内部元素类型为数组，那么降维后就是指向数组的指针，即数组指针
5 错误，利用前面知识，arr首先和[]结合是一个数组，其次和指针结合是一个指针数组，和4分析的不同
6 正确，同理，arr先和*结合是一个指针，再和[]结合，是一个数组指针，和4分析的相同
7错误 ，同理不分析了

四、函数指针

看一段代码

#include 
void test()
{
	printf("hehe\n");
}
int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);
	return 0;
}

结果

我们可以总结出一个概念
函数名代表函数的地址，其作用和&函数名等价。

那我们的函数的地址要想保存起来，怎么保存？

下面我们看代码

void test()
{
printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();	//显然pfun2是一个返回值为void*的函数

首先，需要保存test的地址，就要求是一个指针，根据前面学的知识，显然能够看出void (*pfun1)()是一个指针。pfun1先和*结合，说明pfun1是指针，指向的是一个函数，指向的函数无参数，返回值类型为void。pfun1这种定义当时就是函数指针。

五、函数指针数组和指向函数指针数组的指针

5.1 函数指针数组

要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];

答案

parr1 parr1 先和 [] 结合，说明parr1是数组，数组的内容是什么呢？ 是 int (*)() 类型的函数指针

5.2 指向函数指针数组的指针

指向函数指针数组的指针是一个指针 ，指针指向一个数组 ，数组的元素都是函数指针 ;
如何定义

void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[10])(const char*) = &pfunArr;
return 0;
}