C语言指针详解

指针是什么

我们要理解指针是什么，我们要理解以下两点

1. 指针是内存中最小单元的一个编号，也就是地址
2. 我们平常所说的指针是指针变量，是用来存放内存地址的变量

生活中我们把门牌号叫做地址，在计算机中我们把内存单元的编号也称为地址。到这里，我们或许疑惑什么是内存单元的编号

计算机CPU在处理数据时，需要在内存中读取数据，处理完的数据也会放回内存中，电脑的内存是8G/16GB/32GB等，为了高效的管理这些内存空间，把内存划分为一个个的内存单元，每个内存单元的大小取1个字节，每个单元都有一个编号，有了这个内存单元的编号，CPU可以快速找到一个内存空间

只要讲指针，就离不开内存，指针就是用来访问内存的。
所以我们可以理解为
内存单元的编号 = 地址 = 指针
指针变量

存放内存单元的地址（编号）的变量，存放在指针变量中的值都被当成地址处理

我们可以通过一个代码来理解

#include <stdio.h>
int main()
{
	//在C语言中创建变量就是向内存申请空间
	int a = 666;//在内存中中开辟一块的空间，存放a变量
	int* p = &a;//对变量a取地址，这里使用了取地址操作符(&)，
				//将a的地址存入变量p，p就是一个指针变量
	return 0;
}

到这里或许还有一个疑惑：这里是如何编址的

计算机的编址并不是把每个字节的地址记录下来，而是通过硬件设计完成的。首先，我们应该知道计算机内是有很多硬件单元，而硬件单元是要互相协同工作的。所谓的协同，至少是相互之间能够进行数据传递。但是硬件与硬件之间是相互独立的，他们之间是通过“线”连起来的，我们现在先只关心cpu和内存在进行大量数据交互时所需要的一组线，叫做地址线。
对于32位的机器，有32根地址总线，每根线只有两态，表示0，1（电脉冲有无），那么一根线就能表示两种含义，2根线就能表示4种含义，以此类推，32根线就能表示2的32次方种含义，也就是能形成2的32次方个地址，每个地址标识每一个字节，那么我们就可以给（2³²Byte = 2³²/1024KB = 2³²/1024/1024MB = 2³²/10245/1024/1024GB = 4GB）4G空闲的空间进行编址。同样的方法我们也可以算出64位的机器能编址多大的空间。

这里我们就明白了

• 在32位的机器上，地址是32个0或1组成的二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小应该是4个字节
• 如果在64位机器上，如果有64根地址线，那一个指针变量的大小是8个字节才能存放一个地址
• 注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下大小是相同的
• 我们可以通过代码进行验证

#include <stdio.h>
int main()
{
	printf("%zd\n", sizeof(int*));
	printf("%zd\n", sizeof(short*));
	printf("%zd\n", sizeof(long*));
	printf("%zd\n", sizeof(char*));
	printf("%zd\n", sizeof(double*));
	printf("%zd\n", sizeof(float*));
	return 0;
}

					X64(64位机器)环境输出结果

					X86(32位机器)环境输出结果

指针类型

我们都知道变量有不同的类型，有整型，浮点型等等，指针也是有类型的，我们从上面的代码也不难看出。那我们要如何理解指针的类型呢？

int a = 0;
int * pa = &a;

这里pa左边写的是int*， *是在说明pa是指针变量，而前面的int说明pa指向的是整型类型的对象。其他类型也不难理解。

讲到这里，我们就不得不讲一下学习指针的两个必须要学习的操作符了，那就是取地址操作符（&）和解引用操作符（*）

#include <stdio.h>
int main()
{
	int a = 10;
	&a;//&是一个单目操作符，取出a的地址
	printf("%p", &a);//%p用来打印地址
	return 0;
}

通过上面的例子我们可以知道&a取出的是a所占4个字节中地址较小的字节的地址。
虽然整型变量占用4个字节，我们知道了第一个字节的地址，顺藤摸瓜访问到4个字节的数据也是可行的。

对于我们拿到一个地址，想通过地址(指针)找到地址指向的对象，就得用到解引用操作符(*)。

#include <stdio.h>

int main()
{
	int a = 10;
	int* pa = &a;
	*pa = 0;//*是解引用操作符，通过pa中存放的地址找到指向的空间，*pa其实就是a变量了
			//*pa = 0;其实就是将a改成0；
	return 0;
}

指针变量类型的意义

指针变量的大小和类型无关，只要是指针变量，在同一个平台，大小都是一样的，为什么还要有各种各样的指针类型呢？

1. 指针的解引用
   我们可以通过代码来对比理解指针变量类型对指针解引用的影响

#include <stdio.h>
int main()
{
	int n = 0x11223344;
	int* pi = &n;
	*pi = 0;
	return 0;
}

我们对这段代码进行调试看执行完*pi = 0前后内存中存储的值的变化


再来一段代码进行对比

#include <stdio.h>
int main()
{
	int n = 0x11223344;
	char* pc = (char*)&n;
	*pc = 0;
	return 0;
}

调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只将n的第一个字节改为0.
结论： 指针的类型决定了对指针的解引用的时候有多大的权限(一次能操作几个字节)。
比如：char的指针解引用就只能访问一个字节，而int的解引用就能访问四个字节。

2. 指针±整数
   我们依然通过代码来理解

#include <stdio.h>
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+1 = %p\n", pi + 1);
	return 0;
}

我们可以看出，char类型的指针变量+1跳过1个字节，int类型的指针变量+1跳过了4个字节，这就是指针变量的类型差异带来的变化
结论： 指针的类型决定了指针向前或者向后走一步有多大(距离)。

3. void* 指针
   在指针类型中有一种特殊的类型是void* 类型的，可以理解为无具体类型的指针(或者叫泛型指针)，这种类型的指针就可以用来接受任意类型的地址，但是也有局限性，void* 类型的指针不能直接进行指针的±整数和解引用的运算。
   那么void* 类型的指针到底有什么用呢？
   void* 类型的指针是在使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的结果。使得一个函数来处理多种类型的数据。

const 修饰指针

1. const修饰变量
   变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量的也可以修改这个变量。但是，如果我们希望这个变量不能被修改，就需要用到const。

#include <stdio.h>
int main()
{
	int m = 0;
	m = 20;//m是可以修改的
	const int n = 0;//n具有了常属性（不能被修改），但它不是常量，是常变量。
					//在C++中const修饰的变量是常量
	n = 20;//n是不可以修改的
	return 0;
}

上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n进行修改，就不符合语法规则，就报错，致使没法直接修改n。

但是，如果我们绕过n，使用n的地址，去修改n就能做到了，但是这样做是在打破语法，我们继续用代码来理解。

#include <stdio.h>
int main()
{
	const int n = 0;
	printf("n = %d\n", n);
	int* p = &n;
	*p = 20;
	printf("n = %d\n", n);
	return 0;
}

我们看到n确实是被修改的，但是我们明明就是要用const来修饰来使其不能被修改的，如果p拿到n的地址就能修改，这样就打破了const的限制，这是不合理的，所以我们应该让p拿到n的地址也不能修改n，这就需要我们理解const修饰指针变量

2. const修饰指针变量
   我们通过几段代码来学习
   

const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变，但是如果指针变量本身的内容可变

const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能被修改，但是指针指向的内容，可以通过指针改变。

如果我们在*前后都加了const，那么指针变量的内容不可以修改，指针变量指向的内容也不可以修改。

这样我们就学会了const如何来修饰指针变量了

指针运算

指针的基本运算有三种，分别是;

• 指针±整数
• 指针-指针
• 指针的关系运算

1. 指针±整数

举个例子：指针+1
int a = 0;
int* p = &a;
p+1我们可以理解为跳过4个字节，也就是跳过1* sizeof（int）
所以，当type* 指针p，p+1就是跳过1* sizeof（type）, p+n也就是n* sizeof（type）

我们通过数组来学习，因为数组在内存中是连续存放的，只要知道第一个元素的地址，我们就能找到后面的所有元素。

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));//指针+整数来访问每个元素
	}
	return 0;
}

2. 指针-指针

我们可以这样理解，指针-整数=指针，那指针-指针=整数，这个整数指的就是两个指针之间元素个数的绝对值，那存不存在指针+指针呢？答案是否定的，我们都知道指针是地址，地址加地址得到一个啥，我们并不知道，也没有任何意义。

我们通过模拟实现一个统计字符串长度的函数（strlen）的代码来理解。在此之前我们应该知道strlen函数是统计\0之前字符串的个数。

#include <stdio.h>
int my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
		p++;
	return p - s;
}
int main()
{
	char str[] = "abcddef";
	printf("%d", my_strlen(str));
	return 0;
}

3. 指针的关系运算

指针的关系运算就是指针和指针比较大小，也可以说是地址和地址比较大小。我们通过代码来理解。

#include <stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[0];
	while (p < arr + sz)
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

野指针

概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

1. 野指针成因

• 指针未初始化

#include <stdio.h>
int main()
{
	int* p;//局部变量指针未初始化，默认为随机值,系统会报错
	*p = 20;
	return 0;
}

• 指针越界访问

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int* p = &arr[0];
	for (i = 0; i <= 11; i++)
	{
		//当指针指向的范围超出数组arr的范围时，p就是野指针
		*(p++) = i;
	}
	return 0;
}

• 指针指向的空间释放

#include <stdio.h>
int* test()
{
	int n = 100;
	return &n;
}
int main()
{
	int* p = test();//当调用完函数后，函数里面变量n的空间被释放，
					//p所指向的地址是被释放的空间，属于非法访问，是野指针
	printf("%d\n", *p);
	return 0;
}

2. 如何规避野指针

• 指针初始化

如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NULL，NULL是C语言中定义的一个标识符常量，值是0，0也是地址，这个地址是无法使用的，读写该地址会报错。

• 小心指针越界

一个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。

• 指针变量不再使用时，及时置NULL，指针使用之前检查有效性

当指针变量指向一块区域的时候，我们可以通过指针访问该区域，后期不再使用这个指针访问空间的时候，我们可以把该指针置为NULL。因为约定俗成的一个规则就是：只要NULL指针就不去访问，同时使用指针之前可以判断指针是否为NULL。

• 避免返回局部变量的地址

assert断言

assert.h头文件定义了宏assesrt()，用于在运行时确保程序符合指定条件，如果不符合，就报错终止执行。这个宏常常被称为“断言”

assert(p != NULL);

上面代码在程序运行到这一行语句时，验证变量p是否等于NULL。如果确实不等于NULL，程序继续执行，否则就会终止执行，并且给出报错信息提示。
assert()宏接受一个表达式作为参数。如果该表达式为真（返回值非零），assert()不会产生任何作用，程序继续执行。如果该表达式为假（返回式为零）， assert()就会报错，在标准错误流stderr中写入一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。
assert()的使用对程序员是非常友好的，使用assert()有几个好处：它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启和关闭assert()的机制。如果已经确认程序没有问题，不需要再做断言，就在 #include <assert.sh> 语句的前面，定义一个宏 NDEBUG 。

#define NDEBUG
#include <assert.h>

然后，重新编译程序，编译器就会禁用文件中所有的assert()语句。如果程序又出现了问题，可以移除这条 #define NDEBUG 指令（或者把它注释掉），再次编译，这样就重新启用了assert()语句。
assert()的缺点是，因为引入了额外的检查，增加了程序的运行时间
一般我们可以在Debug中使用，在Release版本中选择禁用assert就行，在VS这样的集成开发环境中，在Relaese版本中，直接就是优化掉了。这样在Debug版本写有利于程序员排查问题，在Release版本不影响用户使用时程序的效率。

传值调用和传址调用

学习指针的目的是使用指针解决问题，那什么问题，“非指针不可呢？
例如：写一个函数，交换两个整型变量的值
我们可能会写出如下代码：

#include <stdio.h>
void Swap1(int x, int y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a = %d b = %d\n", a, b);
	Swap1(a, b);
	printf("交换后：a = %d b = %d\n", a, b);
	return 0;
}

运行代码，结果如下：

我们发现其实没产生交换的效果，这是为什么呢？

我们发现在main函数内部，创建了a和b，a的地址是0x00000081b83afc64，b的地址是0x00000081b83afc64，在调用Swap1函数时，将a和b传递给了Swap1函数，在Swap1函数内部创建了形参x和y接收a和b的值，但是x的地址是0x00000081b83afc40，y的地址是0x00000081b83afc48，x和y确实收到了a和b的值，不过x的地址和a的地址不一样，y的地址和b的地址也不一样，相当于x和y是独立的空间，那么在Swap1函数内部交换x和y的值，自然不会影响a和b，当Swap1函数调用结束后回到main函数，a和b的没交换。Swap1函数在使用的时候，是把变量本身的直接传递给了函数，这种叫传值调用。
结论：实参传递给形参的时候，形参会单独创建一份临时空间来接收实参，对形参的修改不影响实参。
所以我们现在要解决的就是当调用Swap函数的时候，Swap函数内部操作的就是main函数中的a和b，直接将a和b的值交换了。那么就可以使用指针了，在main函数中将a和b的地址传递给Swap函数，Swap函数里边通过地址间接的操作main函数中的a和b，并达到交换的效果。

#include <stdio.h>
void Swap2(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a = %d b = %d\n", a, b);
	Swap2(&a, &b);
	printf("交换后：a = %d b = %d\n", a, b);
	return 0;
}

当我们将变量的地址传递给了函数，可以顺利实现交换，这种函数调用方式叫：传址调用。

传址调用，可以让函数和主调函数之间建立真正的联系，在函数内部可以修改主调函数中的变量；所以未来函数中只是需要主调函数中的变量来实现计算，就可以采用传值调用。如果函数内部需要修改主调函数中变量的值，就需要传址调用。

二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
这就是二级指针。

#include <stdio.h>
int main()
{
	int a = 0;
	int* pa = &a;
	int** ppa = &pa;
	return 0;
}

对于二级指针的运算有：

• *ppa 通过对ppa中的地址解引用，这样找到的是pa，*ppa 其实就是访问pa。

int b = 20;
*ppa = &b;//等价于 pa = &b;

• **ppa 先通过*ppa 找到pa，然后对pa进行解引用操作：*pa ,那找到的就是a。

*ppa = 30;
//等价于*pa = 30;
//等价于a = 30;

指针数组

指针数组是指针还是数组？
我们可以类比一下，整型数组是存放整型的数组，字符数组是存放字符的数组。
那指针数组自然是存放指针的数组。
指针数组的每个元素是地址，又可以指向一块区域。

字符指针变量

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

#include <stdio.h>
int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'l';
	return 0;
}

还有一种使用方式如下：

#include <stdio.h>
int main()
{
	const char* pc = "onward and upward";
	printf("%s", pc);
	return 0;
}

代码const char* pc = “onward and upward”; 很容易让初学者以为是把字符串 onward and upward 放到字符指针pc里面了，但是本质是把字符串 onward and upward 首字符的地址放到了pc中。

数组指针变量

我们都知道指针数组是一种数组，数组中存放的是地址（指针），数组指针变量是指针变量？还是数组？
答案是指针变量，数组指针变量 存放的是数组的地址，能够指向数组的指针变量 。

int (*p)[10];

解释：p先和* 结合，说明p是一个指针变量，然后指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫 数组指针。
注意： []的优先级要高于 * 号的，所以必须加上()来保证p先和 * 结合。
数组指针变量是用来存放数组地址的，那怎么获得数组的地址，就得使用 &数组名。

补充：数组名是数组首元素的地址，但是有两个例外：
sizeof(数组名) ，sizeof中单独存放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
&数组名 ，这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首元素的地址是有区别的，地址+1跳过的字节数是不同的）

函数指针变量

函数指针变量就是用来存放函数的地址的，未来通过地址能调用函数的。
函数是否有地址？我们可以通过代码来验证一下。

#include <stdio.h>
void test()
{
	printf("onward and uopward\n");
}
int main()
{
	printf("test:  %p\n", test);
	printf("&test: %p\n", &test);
	return 0;
}

我们可以看出确实打印出来了地址，所以函数是有地址，函数名就是函数的地址，当然也可以通过&函数名的方式获得函数的地址。指针变量的写法其实和数组指针非常类似。

void test()
{
	printf("onward and upward\n");
}

void (*pf1)() = &test;
void (*pf2)() = test;

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

int (*pf3) (int, int) = Add;//int--pf3指向函数的返回类型，(*pf3)--函数指针变量名，
							//(int, int)--pf3指向函数的参数类型和个数的交代
int (*pf4) (int x, int y) = &Add;//x和y写上或者省略都可以

那么函数指针变量如何使用呢，下面给出一个例子：

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

函数指针数组

把函数的地址放到数组中，那这个数组就叫函数指针数组。

int (*parr1[3]) ();

怎么理解呢？

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

接下来我们用函数指针数组实现加减乘除计算器

#include <stdio.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;
}
int main()
{
	int x = 0, y = 0;
	int input = 0;
	int ret = 0;
	int (*p[5]) (int, int) = { 0, add, sub, mul, div };
	do
	{
		printf("*********************************\n");
		printf("**** 1.add             2.sub ****\n");
		printf("**** 3.mul             4.div ****\n");
		printf("**** 0.exit                  ****\n");
		printf("*********************************\n");
		printf("请选择:");
		scanf("%d", &input);
		if (input <= 4 && input >= 1)
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
			printf("ret = %d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出计算器\n");
		}
		else
		{
			printf("输入有误\n");
		}
	} while (input);
	return 0;
}

好了，指针的内容就说到这了，希望以上的内容对大家学习指针有帮助！