一篇厘清！C语言中的指针

指针的定义

指针与地址

数据在计算机内都是以二进制的形式储存的，这样数量庞大的数据在计算机中自然是有序存储的。

在内存中，每一个储存单元都有一字节的大小，且拥有自己的地址，这个地址也可称为指针。

每个储存单元里都储存着八个比特位，就好像宿舍里一个房间住八个学生一样。

地址使用16进制数字进行编码，比如“0x0000cc19”就是一个地址。地址编码有高有低，地址也就有高地址/低地址之分。那么大小占多个字节的类型的数据该如何储存呢？

大端存储与小端存储

按照“从高到低”或“从低到高”的方式，计算机区分出了大端存储和小端存储。其中，小端存储就是低位存在低地址，高位存在高地址。大端存储就是低位存在高地址，高位存在低地址。

指针的性质

指针可以创建变量

在程序代码中，我们可以创建一个指针变量，里面储存一个地址。

int a - 12;
int* p1 = &a;

这其中p1就是一个指针变量，里面存放着变量a的地址。其中*表示这是一个指针变量，int表示这个指针变量是整型指针变量。

解引用操作符*

当我们想使用这个指针指向的内容时，可以使用解引用操作符*，如：

int a = 5;
int * p = &a;
*p = 20;

 其中*p=20就相当于a=20。

空指针与野指针

试想：如果我们在使用完一个指针后，不对它做任何处理，会发生什么？

int * p1 = NULL;

void PrintNumber (int a)
{
    p1 = &a
    printf("%d",*p1);
    return;
}

int main () 
{
    int a = 10;
    PrintNumber(a);
    return 0;
}

当PrintNumber函数执行完之后，形参a的内存被释放，p1就相当于指向了内存中随机的一块空间。在未来我们续写这段代码的时候，如果意外地修改了p1指针所指向的地址中的内容，那么可能会造成一些不可挽回的损失。这种指向内存中其它的不在程序操控范围内的指针就像野指针。

指针就像是狗，如果让指针变量指向程序操控范围内的空间（例如局部变量所在的内存空间），这条“狗”就被栓了起来，不仅无害，还可以为人看家。但如果指针指向了一块未知的内存空间，那么它就像一条没有栓起来的野狗，会对内存中的数据造成威胁。

所以为了避免野指针的出现，我们需要及时把用完的指针置空。如果我们把指针变量的内容设置为NULL，那我们就创建了一个空指针。空指针不指向任何内存空间，因此是无害的。

指针未初始化，指针访问越界，指针指向已释放的空间都会造成野指针。

所以尤其要记得初始化指针（如果不知道新创建的指针变量应指向哪，就将它设为空指针。）

还有在使用指针访问数组，结构体时要特别注意越界访问的问题。

在使用指针访问malloc,relloc等函数申请的空间时，一定要注意在使用完这些空间后把指针置空。

const修饰符

const相当于一个只读标记，当它修饰一个变量时，该变量不可被修改。

const int a = 5;

在程序中写下这样一句代码，就代表a的值一定是5。

使用const修饰符有两大优点：

1.可以防止后续无意代码修改了不该被修改地变量，减少了bug。

2.使得代码的意图更清晰，增强可读性。一些库函数的说明中，往往会在参数列表里用const修饰一些参数，就代表这些作参数的变量在函数中是只读的，不会修改这些变量的内容。（如在strlen函数的说明中，该函数的声明写为size_t strlen ( const char * str );，其中const char* str就表示传入该函数的指针只读。）

不过一个被const修饰的变量，是可以通过指针修改的，如：

const int a = 5;
int * p1 = &a;
*p1 = 20;

运行之后，通过解引用p1（*p1），a的值将被修改为20。

那么有没有方法，让p1无法改变a的值呢？

如果这样创建一个指针变量，那么它将不能改变a的值：

const int a = 5;
const int * p1= &a;

这时const修饰的是指针所指的内容（即常量指针，指向“常量”的指针），p1不能改变指向内容的值，但是p1可以随便指向别的地方。

如果像这样：

const int a = 5;
int * const p1 = &a;

这时const修饰的就是指针本身了（即指针常量，指针类型的“常量”），p1可以改变指向内容的值，但p1只能指向初始化时所指的区域。

指针类型与指针运算

指针类型决定了指针的权限 

 从上面的示例代码中也可以看出，指针是具有类型的。那么指针的类型有什么意义呢？请看下面这段代码：

int main() 
{
	int a = 8257;
	int* p1 = &a;
	char* p2 = &a;
	printf("%d %c\n", *p1, *p2);
	return 0;
}

输出结果为：

可以看出，p1和p2都是&a，按照读代码的逻辑，两者指向的地址是一样的，解引用之后的值也应该是一样的，可为什么打印出来的数据完全不同呢？

这是因为，指针变量的类型决定了指针解引用的权限（即一次能操作几个字节）。 一次能操作的字节数和该类型的大小相等。（如char类型大小为1字节，char*一次就只能操作1个字节，int类型大小为4字节，int*一次就只能操作4个字节）

在示例中，p1是int类型的指针变量，一次可以操作4个字节，而p2是char类型的指针变量，一次只能操作1个字节。在小端存储的情况下，变量a在内存中表示为“41 20 00 00”(从低地址到高地址)（8257的16进制表示为0x2041，而十六进制位的1位数字可以直接转换成等值的4位二进制数字），p1一次可以读取全部的4个字节，所以解引用后得到a的值8257，而p2是char类型的指针变量，一次只可以读取1个字节，所以它只读取到了“0x41”即“65”，65根据ASCII码转换得到字母“A”，所以*p2得到的值就是‘A’。

指针类型决定了指针“一步”的长度

int main()
{
 int n = 10;
 char *pc = (char*)&n;
 int *pi = &n;
 
 printf("&n = %p\n", &n);
 printf("pc = %p\n", pc);
 printf("pc+1 = %p\n", pc+1);
 printf("pi = %p\n", pi);
 printf("pi+i = %p\n", pi+1);
 return 0;
}

上述代码的输出结果为：

 从输出结果中可以看出，所有类型的指针，指向同一块空间时的起点是相同的。但是当指针+-整数时，指针实际上“跨过”的地址数量等于其类型的大小。

void*指针

void*指针可以接收任何其它类型的指针（如整形指针，字符指针，都可以用一个void*类型的指针变量接受），void*指针常用于函数参数列表中，用以接收各类型指针以让函数处理各类型的数据。

指针的运算

指针+-整数

从上述例子中可以看出，指针+-整数会让指针向后/向前移动，移动的内存单元数等于该整数*指针类型大小。

下面通过一段代码体现指针相减与指针比较。

int main()
{
	int a[5] = { 1,2,3,4,5 };
	int* p1 = &a[0];
	int* p2 = &a[4];
	if (p1 > p2) {
		printf("p1>p2\n");
	}
	else if (p1 < p2) {
		printf("p1<p2\n");
	}
	else {
		printf("p1=p2\n");
	}
	printf("p2-p1= %d\n", p2 - p1);
	printf("p1-p2= %d\n", p1 - p2);
	return 0;
}

输出结果为：

指针相减

同类型的指针之间可以相减，得到的值是两个指针之间相差的元素数（有正负）

注意：指针之间不可以相加

指针比较

指针之间可以比较大小，其实比较的就是地址的高低

数组的访问

数组名的理解

在大部分情况下，数组名实际上就是数组首元素的地址。我们在函数传参的时候，看似输入的是整个数组的名字，实际上是传入了数组首元素的地址。

int main()
{
 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 printf("&arr[0] = %p\n", &arr[0]);
 printf("arr = %p\n", arr);
 return 0;
}

输出结果为： 

数组的访问

因为数组在内存中是连续储存的，当程序想要访问一个数组时，只需要拿到数组首元素的地址，然后依次向后移动，就可以访问到整个数组。

数组的访问示例：（依次访问arr[0],arr[1]......，并打印它们的地址）。可以看到，在该整型数组中，因为一个元素大小为4字节，所以每往后访问一个元素，指针就往后移动4个地址。这不仅证明了数组在内存中是连续储存的，也体现出数组访问的本质

int main() {
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (int i = 0; i < 10; i++) {
		printf("arr[%d] is in %p\n", i, &arr[i]);
	}
	return 0;
}

这个过程时可以直接使用指针变量实现的，如：

int main() {
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	for (int i = 0; i < 10; i++) {
		printf("arr[%d] is in %p\n", i, p);
		p++;
	}
	return 0;
}

就使用了整型指针p访问了整个数组。

实际上,p[i]=(*p+i)，所以代码中也可以直接使用p[i]得到数组中下标为i的元素的值。

int main() {
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	for (int i = 0; i < 10; i++) {
		printf("arr[%d] is %d,%p\n", i, p[i],&(p[i]));
	}
	return 0;
}

关于数组名的两个特例

现在我们知道了，数组名等于数组首元素的地址。但是这里有两个特例需要记住：

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

 可以看到，前两行是arr和arr+1，中间隔了4个地址，这说明指针跳过了一个元素，符合“数组名等于数组首元素地址”。但是后两行是&arr和&arr+1，中间空了20个地址，这是整个数组的大小。这说明&arr是整个数组的地址，跳过的是一整个数组的大小。

还有一个特例是sizeof(arr)时，这其中的arr代表的也是整个数组，得到的也是整个数组的大小。

int main() {
	int arr[5] = { 1,2,3,4,5 };
	
	printf("%d\n%d", sizeof(arr), sizeof(arr[0]));
	
	return 0;
}

综上，在以下两种情况中，arr表示整个数组：

1.arr前有取地址符&，表示取出整个数组的地址。

2.sizeof(arr)，表示计算整个数组的大小。

二级指针

先前我们已说过，可以用指针变量存放地址。

指针变量也是变量，它们也有地址。在代码中可以再创建一个指针变量用来存放指针的地址，这便是二级指针。

不难想到，二级指针也有自己的地址，于是又可以创建一个“三级指针”，三级指针也有自己的地址......以此类推，这个过程可以无限进行下去。

对于二级指针，当我们解引用时，我们得到的是二级指针变量中存放的地址，我们可以进行两次解引用，得到地址指向的空间中内容的值。

int main() {
	int a = 5;
	int* pa = &a;
	int** ppa = &pa;
	printf("%p\n", ppa);
	printf("%p\n", &pa);
	printf("%p\n", *ppa);
	printf("%p\n", pa);
	printf("%d\n", **ppa);
	return 0;
}

指针数组与数组指针 

这俩我总分不清，所以放在一起写。

指针数组

整型数组是存放整型数字的数组，字符数组是存放字符的数组。以此类推，指针数组就是存放指针的数组。其中每一个指针又可以指向一块空间。

创建指针数组示例：

int* arr[5];

数组指针 

数组指针就是指向数组的指针，创建与初始化方法如下所示：

int main() {
	char chlist[10] = { 'A' };
	char(*pca)[10] = &chlist;
	printf("%p %p", &chlist, pca);
	return 0;
}

综上，名字与谁结合，就具有谁的性质。

如：

int * parr[5]，数组名parr与[5]结合，就具有数组的性质，因此是指针数组（存放5个int指针的数组）

float(*parr)[5]，在括号的作用下，parr与*结合，就具有指针的性质，因此是数组指针（指向一个存放了五个浮点型数据的数组）。

函数指针

函数的地址

我们写一段代码，试着取出函数的地址，来看看函数是否具有地址。

int main() {
	printf("%p\n", Test);
	printf("%p\n",&Test);
	return 0;
}

可以看到，对函数使用取地址操作符，不仅没有报错，而且还真的得到了一个地址。如此看来，函数真的有地址，而且函数名就等于函数的地址。

函数指针变量

函数指针变量创建的写法是：

（函数返回类型）+（*函数名）+（参数列表（可写形参变量名，也可只写参数类型））

如：int(*pf3)(int,int)就表示一个指向返回int类型数据，参数列表为两个int类型数据的函数。

可以通过函数指针访问函数，如：

int Add(int x, int y)
{
 return x+y;
}
int main()
{
 int(*pf3)(int, int) = Add;
 
 printf("%d\n", (*pf3)(2, 3));
 printf("%d\n", pf3(3, 5));
 return 0;
}

函数指针变量的复杂性

由于函数指针声明语句的书写格式较为复杂，在使用函数指针变量时，可能会出现一些复杂甚至诡异的代码，如：

(*(void (*)())0)();

这是一个函数的调用，它将数字0看作是一个无返回值，参数列表为空的函数的地址，然后对这个地址进行解引用，并传参。

void (*signal(int , void(*)(int)))(int);

这是一个函数的声明，signal是一个函数，它的参数列表中有两个参数，第一个参数是int类型的，第二个参数是一个函数指针（指向一个无返回值，有一个int类型参数的函数）。这个signal函数的返回类型又是一个函数指针（指向一个无返回值，有一个int类型参数的函数）。

可以看到，因为函数指针的写法（把标识符写在括号中和*放在一起），和函数指针相关的语句的可读性大大降低。

typedef

使用typedef语句可以简化函数指针的写法，进而大大降低函数指针相关代码的复杂度。

int Add(int x, int y)
{
	return x + y;
}

typedef int(*COMPUTE)(int, int);
//typedef 类型+标识符，函数指针的标识符同星号一起放在括号里

COMPUTE Muti(int x, int y) {
	return x * y;
}

int main()
{
	int(*pf3)(int, int) = Add;
	COMPUTE pf4 = Muti;
	printf("%d\n", pf3(2, 3));
	printf("%d\n", pf4(3, 5));
	return 0;
}

在这一段代码中，我们就用typedef关键字把所有返回int，参数列表为两个int类型数据的函数统一定义成COMPUTE，并用这个类型创建函数指针pf4，一目了然。

函数指针数组

作为变量，函数指针当然也可以创建一个数组。同类型（即返回类型，参数列表都相同）的函数的指针可以存放在同一个数组中。

函数指针数组的声明方式为：

int (*parr1[3])();
//返回类型+（*标识符[数组长度]）+（参数列表）
//标识符先跟数组结合成为数组

指针的应用

二维数组

通过学习我们已经知道，数组在内存中是连续储存的，二维数组当然也是如此。通过指针，我们可以对二维数组的一些性质有更深刻的理解，也可以模拟二维数组。

二维数组传参

二维数组可以看作是一个元素是一维数组的数组，当将一个二维数组传参时，按照一维数组传参的实质，传过去的也是一个地址，即第一行的一维数组的地址。即二维数组传参传的是数组指针。程序在访问二维数组的时候，指针再按照每行中数据的类型大小进行移动即可。

这也能解释为什么在创建二维数组的时候，行数可以省略，而列数不能省略：因为列数才是二维数组的“长度”，而行数只是二维数组的元素的长度。

当我们理解了二维数组传参的本质时，就可以直接使用指针变量进行二维数组传参了，这大大提升了代码的灵活性：在一些方法的参数列表中使用二维数组作为参数，还需要确定二维数组的列数，行数。而使用指针作为参数传参，则只需要确定指针类型即刻，如果配合void*指针的话，还可以传入任意类型，任意大小的二维数组。

模拟二维数组

运用指针变量，我们可以模拟二维数组。方法如下:

int main(){
int arr1[5]={1,2,3,4,5};
int arr2[5]={6,7,8,9,10};
int arr3[5]={11,12,13,14,15};
int* arr[3]={arr1,arr2,arr3};
//创建“二维数组”
for(int i=0,i＜3,i++){
for(int j=0,j＜5,j++){
printf("%d",arr[i][j]);
}
printf("/n");
}
//访问并打印模拟的二维数组中的每一个元素
}

模拟二维数组，主要使用的是指针数组。 

转移表与回调函数 

计算器案例

运用typedef，指针数组，函数指针，我们不难写出这样一个计算器的代码：

typedef int (*COMPUTE)(int x, int y);//函数指针的写法太复杂了，所以一开头就把它定义成简单的形式
//用到了typedef

COMPUTE Add(int x, int y) {
	return x + y;
}

COMPUTE Minus(int x, int y) {
	return x - y;
}

COMPUTE Multiple(int x, int y) {
	return x * y;
}

COMPUTE Divide(int x, int y) {
	return x / y;
}
//四种基本运算的函数实现
int main() {
	int input = 1;

	COMPUTE calculator[5] = { 0,Add,Minus,Multiple,Divide };//运用一个函数指针数组实现对四个函数的集中调用
	//核心：函数指针数组

	printf("******************************\n");
	printf("*****   1.ADD   2.MINUS   ****\n");
	printf("***** 3.MULTIPLE 4.DIVIDE ****\n");
	printf("*****       0.exit        ****\n");
	printf("******************************\n");
	//菜单
	do {
		printf("please press your mode code\n");
		scanf("%d", &input);//输入数字选择计算模式
		if ((input > 0) && (input < 5)) {
			int x = 0, y = 0;
			printf("please press your numbers\n");
			scanf("%d%*c%d", &x, &y);//输入操作数
			printf("%d\n", (*calculator[input])(x, y));//打印计算结果
		}
		else if (input != 0) {
			printf("worse input,again please\n");//如果输入了错误的数字，警告并重来一次
			printf("\n");
			printf("******************************\n");
			printf("*****   1.ADD   2.MINUS   ****\n");
			printf("***** 3.MULTIPLE 4.DIVIDE ****\n");
			printf("*****       0.exit        ****\n");
			printf("******************************\n");
			continue;
		}
		else
			printf("EXIT");//当输入为0时退出程序
	} while (input);
	return 0;
}

运行效果

转移表

转移表实质上就是一个便于程序员集中调用函数的函数指针数组，如案例中的calculator

回调函数

回调函数就是通过一个函数指针调用的函数，如果我们直接将函数的指针作为参数，放到另一个函数中进行使用，那么被调用的那个函数就称为回调函数。