十二、指针（一）

1 内存和地址

1.1 内存

想象生活中的一个案例：

假设有一栋宿舍楼，楼里有100个房间，你就住在其中一个房间，但是房间没有编号，此时你的朋友来找你玩，如果想找到你，就得挨个房间去找，这样效率就会很低，但是如果能根据楼层和楼层房间的情况，给每个房间进行编号，你的朋友就能根据房间号快速找到你。

那CPU在处理数据的时候，需要的数据是在内存中进行读取的，处理后的数据也会再放回内存中。电脑常见的内存是8GB/16GB/32GB等等，那要高效地对这些内存空间进行管理，其实也是把它们划分为一个个的内存单元，每个内存单元的大小取1个字节。

计算机中常见的内存单位：

bit  - ⽐特位，一个比特位可以存储一个2进制位的1或0.            1byte = 8bit
byte - 字节                                          	   1KB = 1024byte
KB                                                    	   1MB = 1024KB
MB                                                         1GB = 1024MB
GB                                                         1TB = 1024GB
TB                                                         1PB = 1024TB
PB

其中，每个内存单元就相当于一间宿舍，一个字节里面能放8个比特位，就好比一间宿舍能住八个同学。

而每个内存单元也都有一个编号，这个编号就相当于宿舍的门牌号，有了这个内存单元的编号，CPU就可以快速找到一个内存空间。

在计算机中，我们把内存单元的编号称为地址，而C语言中又把地址称为指针。

所以可以理解为：内存单元的编号 = 地址 = 指针

1.2 硬件编址

CPU要想访问内存中的某个字节空间，必须知道这个字节空间在内存中的什么位置。而因为内存中字节很多，所以需要给内存进行编址，就如同宿舍房间很多，需要给房间编号一样。

而计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计来完成。

钢琴、吉他上面没有写上“do、re、mi、fa、sol、la、ti”这样的信息，但演奏者照样能够准确找到每一个琴弦的位置，这是因为制造商已经在乐器的硬件层面上设计好了，并且所有的演奏者都知道，这本质是一种约定出来的共识，而硬件编址也是如此。

首先，我们知道，计算机内有很多的硬件单元，而硬件单元是需要互相协同工作的，至少相互之间要能够进行数据传递。

但是硬件与硬件之间又是相互独立的，要实现通信，就要用“线”连接起来。

CPU和内存之间就存在大量的数据交互，其中就存在一组“线”——地址总线。

我们可以简单认为，32位机器有32根地址总线，如果每根线只能用0和1表示自己的状态，那么1根线就可以表示2种状态，2根线可以表示4种状态，以此类推，32根线就能表示2^32种状态，而每一种状态恰恰就代表了一个地址。

地址信息被下达给内存，在内存上就可以找到该地址对应的数据，将数据通过数据总线传入CPU寄存器，这样就实现了CPU和内存之间的数据交互。

2 指针变量和地址

2.1 取地址操作符（&）

理解了内存和地址的关系，我们就明白了，在C语言中，变量创建的本质其实就是向内存申请空间。

例：

#include <stdio.h>
int main()
{
	int a = 10;
	return 0;
}

上述代码就是创建了整型变量a，向内存中申请4个字节，用于存放整数10，其中每个字节都有地址，上图中4个字节的地址分别是：

0x00E3F8D8
0x00E3F8D9
0x00E3F8DA
0x00E3F8DB

要想得到a的地址，就需要用到取地址操作符（&）。

#include <stdio.h>
int main()
{
	int a = 10;
	&a;//取出a的地址
	printf("%p", &a);
	return 0;
}

输出结果：

注意：&a取出的是a所占4个字节中地址较小的字节的地址，虽然整型变量占用4个字节，但是只要知道了第一个字节的地址，顺藤摸瓜访问到第四个字节的数据也是可行的。

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

2.2.1 指针变量

从刚才的测试我们知道通过取地址操作符拿到的地址是一个数值，为了方便后期使用这个数值有时候也是需要存储起来的。而这样的地址值就是存放在指针变量中。

例：

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;//取出a的地址并存储到指针变量pa中
	return 0;
}

指针变量也是一种变量，这种变量专门用来存放地址，存放在指针变量中的值也都会被理解为地址。

2.2.2 理解指针类型

int a = 10;
int* pa = &a;
char ch = 'w';
char* pc = &ch;

上面的例子中，pa左边写的是 int* ，* 是在说明pa是指针变量，而前面的 int 是在说明pa指向的是整型（int）类型的对象。同理，pc代表的是一个指向字符（char）类型的指针变量。

2.2.3 解引用操作符（*）

想要使用地址，就要用到解引用操作符（*）。

例：

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;//取出a的地址并存储到指针变量pa中
	printf("%d\n", a);
	*pa = 0;//解引用操作符
	printf("%d\n", a);
	return 0;
}

输出结果：

上面代码中第7行就使用了解引用操作符， *pa 的意思就是通过pa中存放的地址，找到指向的空间。而 *pa 其实就是a变量，所以 *pa=0 的意思就是把0赋给a。

2.3 指针变量的大小

前面我们认识到，假设32位机器有32根地址总线，把32根地址线产生的二进制序列当作一个地址，那么一个地址就是32个比特位，需要4个字节才能存储。由于指针变量是用来存放地址的，所以指针变量的大小也得是4个字节才可以。

同理，对于64位机器，假设64位机器有64根地址总线，那么一个地址就是64个比特位，存储起来就需要8个字节的空间，指针变量的大小就是8个字节。

例：

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

输出结果：

结论：

• 32位平台下地址是32个bit位，指针变量大小是4个字节。

• 64位平台下地址是64个bit位，指针变量大小是8个字节。

注意：

指针变量的大小和类型无关，在相同的平台下，只要是指针变量，大小都相同。

3 指针变量类型的意义

既然指针变量的大小和类型无关，那为什么还要区分指针变量的类型呢？

3.1 决定指针解引用的权限

例：对比下面两段代码，在调试时观察内存的变化。

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

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

调试结果：

从调试结果可以看到，代码1会将n的4个字节全部改为0，而代码2只是将n的第1个字节改为0。这正是因为 char* 类型的指针解引用时只能访问1个字节，而 int* 类型的指针解引用就能访问4个字节。

结论：指针的类型决定了指针在解引用时有多大的权限，即一次能操作几个字节。

3.2 决定指针的步长

例：观察下面代码地址的变化。

#include <stdio.h>
int main()
{
	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跳过1个字节，int* 类型的指针变量+1跳过了4个字节，这就是指针变量类型的差异所带来的变化。

结论：指针变量的类型决定了指针向前或向后走一步能跳过多少字节（步长）。

4 const

4.1 const修饰变量

const修饰变量时，变量将不能被修改。

例：

#include <stdio.h>
int main()
{
	int m = 0;
	m = 20;//m是可以修改的
	const int n = 0;
	n = 20;//n是不能被修改的
	return 0;
}

运行结果：

上述代码中，n本质是变量，但是被const修饰后，在语法上加了限制，导致没法直接修改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;
}

输出结果：

4.2 const修饰指针变量

从刚才的输出结果可以看到n确实被修改了，但是用const修饰就是为了让n不能被修改，如果拿到n的地址就能修改，这就打破了const的限制，如果要让p拿到的地址也不能修改n，就要用const来指针变量。

例：

#include <stdio.h>
//测试⽆const修饰的情况
void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 20;//ok?
	p = &m; //ok?
}
//测试const放在*的左边情况
void test2()
{
	int n = 10;
	int m = 20;
	const int* p = &n;
	*p = 20;//ok?
	p = &m; //ok?
}
//测试const放在*的右边情况
void test3()
{
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 20; //ok?
	p = &m; //ok?
}
//测试*的左右两边都有const的情况
void test4()
{
	int n = 10;
	int m = 20;
	int const* const p = &n;
	*p = 20; //ok?
	p = &m; //ok?
}
int main()
{
	test1();
	test2();
	test3();
	test4();
	return 0;
}

运行结果：

结论：

const修饰指针变量的时候：

1. const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能修改。但是可以改变指针指向的方向。

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

3. 如果两边都有const，指针指向的内容和指针变量本身都会被修饰，保证指针指向的方向不能修改，同时指针指向的内容也不能修改。

5 指针运算

5.1 指针+ - 整数

例：访问数组。

#include <stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	//下标的方式访问
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	//指针的方式访问
	int j = 0;
	int* p = &arr[0];
	for (j = 0; j < sz; j++)
	{
		printf("%d ", *(p+i));
	}
	return 0;
}

因为数组在内存中是连续存放，只要知道第一个元素的地址，顺藤摸瓜就能找到后面的所有元素。

输出结果：

5.2 指针 - 指针

例：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int* p = &arr[9];
	int ret1 = *p - (*p - 9);
	int ret2 = (*p - 9) - *p;
	printf("%d %d\n", ret1, ret2);
	return 0;
}

输出结果：

#include <stdio.h>
//计算字符串的长度
#include <stdio.h>
int my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
		p++;
	return p - s;
}
int main()
{
	char arr[] = "abcedf";
	printf("%d\n", my_strlen(arr));
	return 0;
}

输出结果：

结论：指针 - 指针值的绝对值是指针之间元素的个数。

注意：指针和指针能相减的前提是两个指针指向同一块空间。

5.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;//数组名就是数组首元素的地址
	while (p < arr + sz)//arr+sz 是数组结束标志处（\0）的地址
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

输出结果：