指针专题（1）

前言

指针在C语言中占据着重要的位置，对指针的掌握度会直接影响到编写C语言代码的能力，而且指针的难度较大，所以我们要认真的学习指针。那么废话不多说，我们正式进入今天的指针学习

（PS：之前有关指针、结构体、循环的专题没有做，现在把它补上，推荐先把这些专题看完再看数据结构等内容）

1.内存和地址

1.1 内存

我们在生活中都去过宾馆，宾馆的每个房间都有自己的编号，如果宾馆的房间没有自己的编号，那么对于我们而言就很难找到指定的房间，我们就需要一个一个地去寻找房间，那么这样就会导致效率低下的问题，而且会耗费大量的时间

我们可以把以上的例子映射到计算机上。计算机的CPU在处理数据的时候，需要从内存中读取数据，使用后的数据也会放回内存，我们生活中的计算机内存通常是16G/32G等，那么这么大的内存空间要该如何高效的管理呢？

计算机把内存划分为一个一个的内存单元，我们把每个内存单元的大小取定为1个字节

计算机在执行识别、存储、运算的时候都是使用二进制的

我们若要将二进制中的一个位0或者1存储起来，就需要1个bit位--比特位

Byte--字节 1Byte = 8bit

KB 1KB=1024Byte

MB 1MB = 1024KB

GB 1GB = 1024MB

TB 1TB = 1024GB

PB 1PB = 1024TB

在生活中我们给房间号、门牌号进行编号，所以我们也在计算机中给内存编号，有了每个内存单元的编号，计算机就可以很快速的找到一个内存空间

我们在生活中把门牌号叫做地址，在计算机中我们把内存单元的编号也叫做地址。同时，我们给地址起了一个新的名字--指针

也就是说：内存单元的编号 == 地址 == 指针

1.2计算机编址的实现（计算机如何通过地址找到内存单元）

首先我们需要知道，计算机的内部有很多的硬件单元，而且各个硬件单元是需要互相协同工作的，但是硬件单元与硬件单元之间是相互独立的，所以各个单元之间实现通信需要依靠的是"线"

线的类型有很多种，有地址总线、数据总线、控制总线；但是我们今天先单独了解一下地址总线

控制总线决定当前的操作是读还是写

地址总线传输的是地址信号

数据总线传输的是数据

地址总线

我们在选购电脑的时候可以注意到，有些电脑标注的是64位电脑，有些电脑标注的是32位电脑。

那么这里的32和64分别表示什么意思呢？32表示当前的计算机有32根地址线，而64表示有64根地址线

每一根的地址线上可以产生两种信号，分别是0信号和1信号【电脉冲的有无】，我们把所有地址线的数字整合起来就可以表示编号，可以产生2的32次方种编号，每一种编号都可以作为一个地址用来管理内存空间

程序里面的都是虚拟地址，需要转化为物理地址才能被放入内存

总结

1.内存会被划分为一个个的内存单元

2.每个内存单元的大小是一个字节

3.每个内存单元都会给一个编号，该编号也可以称作地址或者指针

4.编译器中地址采取16进制，因为二进制表示很繁琐，但地址本质上还是二进制

2.指针变量和地址

2.1取地址操作符&

若我们写出这样的代码：

int a = 0;

这个变量创建的本质是在内存中开辟一块空间，因为类型是int，所以我们在该空间内申请了4个字节，在这块开辟了的空间中存储了数字0，其中每个字节都有其对应的地址

那我们如何能得到a的地址呢？

我们此时就应该采用&操作符，&a取出的是a所占4个字节中地址较⼩的字节的地址（首地址）

虽然整型变量占⽤4个字节，但是我们只要知道了第⼀个字节地址，只需要顺藤摸⽠就可以访问到其他3个字节的数据

%p 是专门用来打印地址的---以16进制的形式

2.2指针变量和解引用操作符

2.2.1指针变量

之前我们学到了&操作符，我们有时候需要将地址存起来，方便以后使用，那么我们应该把地址存到哪里去呢？答案是存在指针变量中，例如以下代码：

int main(void)
{
	int a = 0;
	int* pa = &a;
	return 0;
}

该代码的意思是取出a的地址并且将其存放到指针变量pa中去

指针变量也是一种变量，该变量是用来存放地址的，存放在指针变量里的值都会被计算机理解为地址

上述代码中的pa变量的类型是 int*，那么我们又该如何理解这里的int呢？

我们要把int*中的int和*分开来理解；

*说明的是pa是一个指针变量

int说明的是pa指向的对象是int类型的

2.2.2解引用操作符

我们之前学习了取地址&操作符和指针变量，那么我们可不可以通过指针找到指针所指向的对象呢？此时我们就需要用到解引用操作符（间接访问操作符）--" * "

我们来观察一下下面的代码：

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

代码中的*pa的含义就是：通过pa中指向的地址，找到其指向的空间，并且对空间里面的内容进行修改。那么此时有人可能会要问了：我们不直接 a = 100，反而要多此一举使用指针呢？这涉及到传值和传址的区别，我们先不作解释，随着我们往下学习，我们的心中自然会有了答案

2.3指针变量的大小

我们知道指针变量也是一个变量，也需要向内存申请空间，这样才有能力存放地址，那么pa空间的大小是多少呢？一个指针变量的大小是多少呢？

指针变量需要多大的空间，取决于指针变量里面存放的是什么。因为指针变量存放的是地址，所以地址的存放需要多大的空间，指针变量大小就是多大

我们之前知道，一个32位的电脑有32根地址线，每根地址线上可以产生0或者1两种信号。所以说在32位电脑上，地址是32个0或者1一起组成的二进制序列

因为一个二进制位存放需要一个bit位，所以将地址储存起来就需要32个bit位，也就是4个字节

故在32位电脑上指针变量的大小就是4个字节。

同理可知，因为64位电脑有54根地址线，所以64位的电脑上指针变量的大小是8个字节

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

需要注意的是：指针变量的大小与类型无关，只与机器是32位还是64位有关

int main(void)
{
	int a = 10;
	char ch = 'a';
	int* pa = &a;
	char* pb = &ch;
	printf("%d\n", sizeof(pa));
	printf("%d\n", sizeof(pa));
	return 0;
}

sizeof用%zd打印会更好，因为%zd是64位环境中专门用来打印sizeof返回值的，打印的是无符号的整数

3.指针变量类型的意义

3.1对指针的解引用

通过之前的学习我们可以知道指针变量的大小和类型⽆关，只要是指针变量，在同⼀个平台下，大小都是⼀样的，为什么还要有各种各样的指针类型呢？

下面我们来看一串代码：

int main(void)
{
	int a,b = 0x11223344;
	int* pa = &a;
	char* pb = &b;
	*pa = 0;
	*pb = 0;
	printf("%x\n", a);
	printf("%x\n", b);
	return 0;
}

b在操作之前的情况：

b在操作后的情况：

通过这一串代码我们知道了：指针的类型决定了对指针解引⽤的时候有多⼤的权限，即一次能操作几个字节

所以说char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节

3.2指针+-整数

我们先来看一下下面的代码，观察地址的变化：

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

我们在这个代码中不难看出：char*类型的变量每次+1会跳过一个字节，而int*类型的变量每次+1会跳过四个字节，这就是指针变量的类型差异带来的变化

所以我们可以得知：指针的类型决定了指针向前或者向后走一步有多大（步长）

我们可以归纳为： type* p p+i相当于跳过了i个type类型的数据

所以我们要根据实际的需要，选择适当的指针类型

3.3 void指针

在指针类型中有一种特殊的类型，他就是void*类型的指针，我们可以把它理解为无具体类型的指针（通常也可以称作泛型指针），这种类型的指针可以接受任意类型的地址，但void指针存在一个局限性，就是void指针不能进行解引用和+-整数的操作

下面我们写一串代码来举例：

int main(void)
{
	int a = 25;
	int* pa = &a;
	char* pb = &a;
	return 0;
}

因为我们给int类型的地址赋给了一个char*类型的指针变量。所以编译器报了警告，因为类型与类型之间不兼容。（若是C++会更加严格，会直接报错）但是我们使用void*类型的指针就不会存在这样的问题（或者使用强制类型转换）

int main(void)
{
	int a = 25;
	int* pa = &a;
	void* pb = &a;
	return 0;
}

⼀般 void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。使得⼀个函数来处理多种类型的数据

4.const修饰指针

4.1 const修饰变量

我们知道，变量是可以被修改的，如果把一个变量的地址给到一个指针变量，那么我们也可以通过指针变量来修改这个变量的值。如果我们不想改变一些变量的值，想限制住这个变量，那么此时我们就需要用到const

int main()
{
	int m = 0;
	m = 20;//m是可以修改的

	const int n = 0;
	n = 20;//n是不能被修改的

	return 0;
}

我们可以看到，在上述的代码中，加入const修饰的n变量在修改的时候出现了红色的下标报错

const表示的是常属性的意思，当变量赋予了常属性以后就不能被修改了，但n本质上还是一个变量，我们来举一个例子：

int main()
{
	const int n = 20;
	int arr[n] = { 0 };
	return 0;
}

在C++中，经过const修饰以后的n就彻底是常量了，但是在C语言中被const修饰以后的变量仍然在本质上是一个变量

此时我们就可以知道：上述代码中n是不能被修改的，虽然n的本质是一个变量，但是n被const修饰后，会在语法层面上加了限制，只要我们在代码中对n就⾏修改，就不符合语法规则，就报错，致使没法直接修改n

但是如果我们绕过n，使⽤n的地址去修改n，就能够实现修改，这样做是在打破语法规则

int main()
{
	const int n = 0;
	printf("n = %d\n", n);
	int* p = &n;
	*p = 20;
	printf("n = %d\n", n);
	return 0;
}

4.2 const修饰指针变量

const修饰指针变量的时候通常分为两种情况：

1.const放在*的左边

int main()
{
	const int a = 10;
	int b = 100;
	const int* p = &a;

	*p = 0;//error
	p = &b;//ok
	return 0;
}

如上述代码所示：const放到*号的左边修饰的对象是*p，所以我们不能通过解引用来改变取值

我们虽然不能改变p指针变量所指向变量的值，但是我们可以改变p指针自己的值，我们可以给p指针变量赋予一个新的地址，这样改变不会出现问题

2.const放到*的右边

int main()
{
	const int a = 10;
	int b = 100;
	int* const p = &a;

	*p = 0;//ok
	p = &b;//error
	return 0;
}

如上述代码所示：const放到*号的右边修饰的对象是p，我们不能修改p本身的值，但p指向的值是可以通过p来改变的

总结

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

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

5.指针运算

5.1指针+-整数

我们在刚才讲解了指针+-整数，现在我们再借用一个例子来加深对指针+-整数的理解：我们知道，数组在内存空间中是连续存放的。所以我们可以通过以下代码来打印数组内容：

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

	return 0;
}

我们来思考一下：我们能不能通过指针来打印数组呢？

因为数组在内存中是连续存放的，随着数组下标的增长，地址是由低到高变化的。所以我们只需要拿到数组的第一个元素的地址就可以知道后面元素的地址

所以我们只要知道数组元素的个数、数组首元素的地址就可以用指针完成数组内容的打印了

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


printf("%d", *p);
p++;
等价于：
printf("%d", *(p + i))

5.2指针-指针

指针-指针我们可以借助我们日常生活中的日期来理解：

日期 + / - 天数 = 日期；

日期 - 日期 = 天数；

日期与日期之间也可以比较大小；

但是日期 + 日期就会出现问题，该运算结果没有意义；

我们把日期的概念以指针的形式理解：

指针 + / - 整数 = 指针；

指针 - 指针 = 整数；

所以指针 - 指针得到的结果是指针与指针之间元素的个数；

指针 - 指针操作的前提是两个指针都指向的是同一块空间；

int main()
{
	int arr[10] = { 0 };
	printf("%d\n", &arr[9] - &arr[0]);
	return 0;
}

指针 + 指针的操作也不存在，因为得到的结果没有意义；

指针 - 指针的应用（strlen的模拟实现）

我们首先需要了解一个函数：

该函数是一个库函数，它的使用需要包含头文件<string.h>，它可以实现计算字符串中字符的个数的功能，strlen遇到字符串里面的 \0 就会停止计算

传入数组名就相当于传入数组首元素的地址，arr == &arr[0]

int main()
{
	char arr[] = "abcdefgh";
	int len = strlen(arr);
	printf("%d\n", len);
	return 0;
}

我们结合刚才所学的指针 - 指针的操作，就可以自己模拟实现strlen了：

方法一：指针 - 指针

int my_strlen(char* p)
{
	char* p1 = p;
	while (*p != '\0')
	{
		p++;
	}
	return p - p1;
}
	
		
int main()
{
	char arr[] = "abcdefgh";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

方法二（非指针 - 指针）

int my_strlen(char* p)
{
	int count = 0;
	while (*p != '\0')
	{
		count++;
		p++;
	}
	return count;
}
		
int main()
{
	char arr[] = "abcdefgh";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

我们最好把返回值的类型设置为size_t，size_t是一个无符号整形的类型，是专门用来表示无符号整数的，最开始size_t是专门用来表示sizeof的返回值的类型的

5.3指针的关系运算

指针是可以支持比较大小的：

int main(void)
{
	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;
}

6.野指针

野指针就是一个指针，但是该指针指向的位置是不可知的

6.1野指针的成因

1.指针未初始化

	int main()
	{
		int* p;//局部变量指针未初始化，默认为随机值
		*p = 20;
		return 0;
	}

因为p没有初始化，它指向的的空间是一个随机值，这样就会造成野指针

2.指针越界访问

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

在原数组里面只有10个元素，而我们通过for循环访问了11个元素，由于第十一个元素是未定义的，这样就导致了空指针

3.指针指向的空间释放

		int* test()
		{
			int n = 100;
			return &n;
		}
		int main()
		{
			int* p = test();
			printf("%d\n", *p);
			return 0;
		}

因为test函数里面创建的是临时变量，当出函数的时候n变量里面的内容就会被销毁，我们虽然可以成功的返回n的地址，但是我们无法找到n中之前存入的值了，现在再解引用就会取出一个未知的值，造成野指针

6.2如何规避野指针

6.2.1指针初始化

如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL

int main(void)
{
	int num = 10;
	int* p1 = &num;
	int* p2 = NULL;
	return 0;
}

NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址会报错

6.2.2小心指针越界

我们向内存空间申请了多少空间，解引用的时候就访问多少空间，不能过度访问，不然会造成指针的越界访问

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

int main()
{
	int arr[10] = { 1,2,3,4,5,67,7,8,9,10 };
	int* p = &arr[0];
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p++) = i;
	}
	//此时p已经越界了，可以把p置为NULL
	p = NULL;
	//下次使⽤的时候，判断p不为NULL的时候再使⽤
	//...
	p = &arr[0];//重新让p获得地址
	if (p != NULL) //判断
	{
		//...
	}
	return 0;
}

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

如之前的第三个例子所示

7.assert断言

<assert.h>头文件中有一个宏叫做assert( )，该宏用于在运行中确保程序符合指定的条件，如果不符合条件，程序就报错并且终止，这个宏也被称作断言

使用assert宏有以下优势：

1.能自动标识⽂件和出问题的⾏号

2.有⼀种无需更改代码就能开启或关闭 assert( ) 的机制

如果已经确认程序没有问题，不需要再做断⾔，就在 #include<assert.h> 语句的前⾯，定义⼀个宏NDEBUG

#define NDEBUG
#include <assert.h>

assert也有缺点：assert会增加程序运行的时间

注：release版本中经过了优化，assert不会被执行

8.传值调用和传址调用

我们通过本节指针的学习可能会感觉指针并没有太大的作用，但是有些情况是非用指针不可的，下面我们来举一个例子：

如果我们想写出一个函数用来交换两个整型变量的取值，我们可能会写出代码如下：

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);
	Swap1(a, b);
	printf("交换前：a = % d b = % d\n", a, b);
	printf("交换后：a = % d b = % d\n", a, b);
	return 0;
}

可当我们运行代码，发现函数并没有完成交换的功能：

我们来分析一下：因为Swap1是我们自己创建的函数，我们把a、b中的取值复制给了临时变量x、y，我们在函数内部对x、y进行修改并不会影响到a、b，而且当出函数的时候x、y都会被销毁，所以我们这样写代码并不能实现交换的功能

结论：实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实参

这样的传值形式叫做传值调用，对函数内部的修改并不会影响到函数外部

那么我们该怎么实现交换的功能呢？我们需要让函数内部的x和y与函数外部的a和b建立联系，此时我们就需要用到传地址

void Swap2(int* px, int* py)
{
	int tmp = 0;
	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;
}