C语言：指针（1-1）

1. 内存和地址

1.1 内存

在学习内存和地址的知识前，我们可以先来看一个生活示例：

假设你住在一栋宿舍楼中，宿舍楼共有100个房间。如果房间没有编号，你的朋友想要找到你时，就需要挨个搜寻每一个房间，这样费时费力，效率低下；可是，当每个房间都编上号后，你的朋友根据编号来搜寻你所在的房间就会容易的多了。

那么，话说好了，我们知道计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如何高效的管理呢？

其实也是把内存划分为⼀个个的内存单元，每个内存单元的大小取1个字节。

计算机中常见的单位（补充）： 一个比特位可以存储⼀个2进制位的1或者0

bit - 比特位
Byte - 字节
KB
MB
GB
TB
PB

1 Byte = 8 bit
1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
1 PB = 1024 TB

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

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

生活中我们把门牌号也叫地址，在计算机中我们 把内存单元的编号也称为地址。C语言中给地址起了新的名字叫：指针。

因此，在C语言中，我们可以这样理解：内存单元的编号==地址==指针

1.2 如何理解编址

CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节 很多，所以需要给内存进行编址(就如同宿舍很多，需要给宿舍编号⼀样)。 计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。

类比乐器，制造厂商并不会在上面标注处发音的信息，但是演奏者却可以通过乐器精准地发出每一个音。这是因为，制造商在乐器硬件层面上就设计好了该怎么发音，并且所有的演奏者都知道，本质是一种约定出来的共识！

首先，必须理解，计算机内是有很多的硬件单元，而硬件单元是要互相协同工作的。所谓的协 同，至少相互之间要能够进行数据传递。 但是硬件与硬件之间是互相独立的，那么如何实现通信呢？答案很简单，用"线"连起来。 而CPU和内存之间也是有大量的数据交互的，所以，两者必须也用线连起来。 不过，我们今天就了解一组线，叫做地址总线。

我们可以简单理解，32位机器有32根地址总线，每根线只有两态，即电脉冲有无表示0,1。那么 一根线，就能表示2种含义，2根线就能表示4种含义，依次类推，32根地址线，就能表示2^32种含义，每一种含义都代表一个地址。 地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。

2. 指针变量和地址

2.1 取地址操作符（&）

理解了内存和地址的关系，我们再回到C语言，在C语言中，创建变量其实就是向内存申请空间，比如：

int a = 10;

那么，我们该如何得到变量a的地址呢？

这个时候就可以拿出我们的取地址操作符 & ，例如：

#include <stdio.h>

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

000000DCEBFFF69C

这样，就可以得到变量a的地址了。但是，我们知道，int类型的数据是占据4个字节，但是通过取地址操作符得到的地址却只有一个，这是为什么呢？

这是因为，&a取出的是a所占4个字节中地址较小的字节的地址，根据第一个字节的地址，我们就能知道其他字节所在的地址。

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

2.2.1 指针变量

那我们通过取地址操作符(&)拿到的地址是⼀个数值，比如：000000DCEBFFF69C，这个数值有时候也是需要 存储起来，方便后期再使用的，那我们把这样的地址值存放在哪里呢？答案是：指针变量中。

例如：

#include <stdio.h>

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

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

2.2.2 如何拆解指针类型

在上面的代码中，我们可以发现，指针变量pa的类型是 int * ，那我们应当如何理解呢？

int a = 10;
int* pa = &a;

我们可以看到，pa左侧是 int* ，int 说明了pa指向的变量的类型是int，而 * 则是说明 pa 是指针变量。

同样的，如果我们要存储一个字符类型的变量的地址，我们就可以写成下面的形式：

char ch = '1';
char* pc = &ch;

2.2.3 解引用操作符

我们学会了如何存储指针变量，那我们应该如何使用呢？

现实中，我们得到房间牌号就可以找到对应的房间。

而在C语言中其实也是一样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针） 指向的对象，而这里就会使用到另一个操作符——解引用操作符 * 。

#include <stdio.h>

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

20

进程已结束，退出代码为 0

这里，我们就利用解引用操作符 * ，通过指针变量 pa 找到了变量 a 的地址， 所以 *pa 就相当于变量 a 。所以 *pa = 20 这一步就将变量a的值为了20。

学习了解引用操作符的用法之后，以后在修改变量的值的时候，我们就多了一种途径，写代码就更加灵活了。

2.3 指针变量的大小

前面的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产生的2进制序列当做一个地址，那么一个地址就是32个bit位，需要4个字节才能存储。

如果指针变量是用来存放地址的，那么指针变的大小就得是4个字节的空间才可以。

同理64位机器，假设有64根地址线，一个地址就是64个二进制位组成的二进制序列，存储起来就需要8个字节的空间，指针变量的大小就是8个字节。

#include <stdio.h>
//指针变量的⼤⼩取决于地址的⼤⼩
//32位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）
 
int main()
{
    printf("%zd\n", sizeof(char *));
    printf("%zd\n", sizeof(short *));
    printf("%zd\n", sizeof(int *));
    printf("%zd\n", sizeof(double *));
    return 0;
}

8
8
8
8

结论：

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

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

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

3. 指针变量类型的意义

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

其实指针类型是有特殊意义的，接下来我们继续学习。

3.1 指针的解引用

我们对比下面两组代码：

#include <stdio.h>

int main()
{
    int n = 273;
    int *pi = &n; 
    *pi = 0;  
    printf("%p\n",pi); 
    return 0;
}

//输出结果
0

#include <stdio.h>

int main()
{
    int n = 273;
    char* pi = (char *)&n;
    *pi = 0;
    printf("%d\n",n);
    return 0;
}

//输出结果
256

我们可以看到，两代码的输出结果不同。64位系统中，代码1会将n的4个字节全部改为0，而代码2则只会更改一个字节。16进制下，273为0x000111，因此，int* 指针可以直接改为0x000000，char* 则会修改为0x000100。

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

比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

3.2 指针和整数进行加减运算

我们通过一组代码来查看地址的变化：

#include <stdio.h>

int main()
{
    int n = 273;
    int *pi = &n;
    char* pc = (char *)&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;
}

&n     = 00000056441FFC7C
pc     = 00000056441FFC7C
pc + 1 = 00000056441FFC7D
pi     = 00000056441FFC7C
pi + 1 = 00000056441FFC80

我们可以看出， char* 类型的指针变量+1跳过1个字节，int* 类型的指针变量+1则跳过了4个字节。 这就是指针变量的类型差异带来的变化。指针+1，其实就是跳过1个指针指向的元素。指针可以+1，那也可以-1。

结论：指针的类型决定了指针向前或者向后走一步有多大（距离）

3.3 void* 指针

指针类型中有一种特殊类型的指针，那就是void* 指针，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性，那就是无法直接进行+-的运算或者是解引用操作。

int main()
{
    int a = 10;
    int* pa = &a;
    char* pc = &a;//编译器发出警告：Incompatible pointer types initializing 'char *' with an expression of type 'int *'
    void* pv = &a;//正常运行
    return 0;
}

#include <stdio.h>

int main()
{
    int a = 10;
    int* pa = &a;
    void* pv = &a;
    *pa = 20;//正常运行
    *pv = 30;//系统报错
    return 0;
}

我们可以发现，void* 指针可以用来接受不同类型的地址，却无法用来直接进行指针运算。

那么，void* 指针有什么用处呢？

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

4. const修饰指针

4.1 const 修饰指针

变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量的也可以修改这个变量。 但是如果我们希望给一个变量加一些限制，不能被修改，该怎么做呢？这个时候我们就可以使用const 。

#include <stdio.h>

int main()
{
    int a = 10;
    a = 20;
    const int b = 10;
    b = 20;//编译器报错
    return 0;
}

上面的代码中，a可以修改，这是因为a本质是变量；但是b是不可修改的，这是因为const修饰之后，就会在语法上对n加上限制，只要我们想要修改b的值，系统就会报错，让我们无法修改b的值。

不过，如果我们绕过n，利用指针，通过n的地址就可以修改n了，但是这样做是在打破语法规则。

#include <stdio.h>

int main()
{

    const int b = 10;
    int* pb = &b;
    *pb = 20;//系统警告：Initializing 'int *' with an expression of type 'const int *' discards qualifiers
    printf("%d",b);
    return 0;
}

//输出结果
20

我们可以看到这里确实成功修改了b的值，但是我们还是要思考⼀下，为什么n要被const修饰呢？就是为了不让b被修改，如果p拿到n的地址就能修改n，这样就打破了const的限制，这是不合理的，所以应该让 p拿到n的地址也不能修改n，那应该怎么做呢？

4.2 const修饰指针变量

一般来讲const修饰指针变量，可以放在 * 的左边，也可以放在 * 的右边，但是这两种形式的意义是不一样的。

我们看代码：

#include <stdio.h>

void test1()
{
    int n = 10,m = 20;
    int* p = &n;
    *p = 30;
    p = &m;
}

void test2()
{
    int n = 10,m = 20;
    int const * p = &n;
    *p = 30;//系统报错
    p = &m;
}

void test3()
{
    int n = 10,m = 20;
    int* const p = &n;
    *p = 30;
    p = &m;//系统报错
}

void test4()
{
    int n = 10,m = 20;
    int const* const p = &n;
    *p = 30;//系统报错
    p = &m;//系统报错
}

int main()
{
    //测试无const修饰
    test1();
    //测试const修饰在左侧
    test2();
    //测试const修饰在右侧
    test3();
    //测试const修饰在两侧
    test4();

    return 0;
}

结论：const修饰指针变量的时候

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

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