C语言指针详解-包过系列（一）目录版

1.内存和地址

1.1内存

我们用生活中的一个例子为例，学生宿舍有各自得房间号，通过房间号就能找到对应房间里的人。以此我们延伸至计算中，CPU（中央处理器）在处理数据的时候，所需数据是从内存中读取的，在处理完毕后也会放回到内存中。
内存中细分为单个的内存单元，每个内存单元大小取1字节。其中每个内存单元，相当于一个学生宿舍，一个字节空间里面可以放8个比特位，就像是一个8人间的宿舍，每个人都占比一个比特位。

同时每个内存单元都有一个编号（就好比于宿舍房间的门牌号），有了这个编号，CPU就可以快速找到对应的内存空间。
在生活中人们管房间号叫做地址，在计算机中我们同样管内存单元的编号叫做地址，在C语言中他有一个新的名字：指针。（内存单元的编号地址指针）

1.2 深入理解编址

计算机中的编址并不是把每个字节的地址记录下来，而是在机器出厂前就已经通过硬件设计好了。
我们知道计算机中每个内存单元都是相对独立的，而每个单元之间又需要有一定的联系，嫁接这种关系的桥梁就是我们下面要提到的各种“线”。
CPU（中央处理器）在需要读取各数据时需要先找到对应数据的地址，在这个过程中需要用到地址总线。当CPU读取数据，数据从内存传到CPU时，需要用到数据总线。在CPU得到数据进行计算，将计算过程传回内存时需要用到控制总线。

在本节，我们主要关注一组线——地址总线。
我们知道32位机器有32根地址总线，每根线只有两态，表示0，1（有无电脉冲），那么一根线两种含义，32根线就有2^32种含义，每一种含义都代表一个地址。地址信息传达给内存后，在内存上就可以找到该地址对应的数据，将数据通过数据总线传入CPU寄存器内。

2.指针变量和地址

2.1 取地址操作符（&）

在上文理解内存与地址的关系后，我们再来看C语言，C语言创建变量其实就是向内存申请内存空间。那么我们如何能得到我们所创建的变量的地址呢。这就需要用到取地址运算符（&）

#include<stdio.h>
int main()
{
    int a = 4;
    printf("%p\n", &a);
}

在上图中打印的就是整型a的地址。
&a 取出的是整型a所占的四个字节中地址较小的字节地址。但因整型变量4个字节的地址申请时是连续的，所以知道最小的地址同时也就顺藤摸瓜地找到另外三个字节地址。

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

2.2.1 指针变量

我们通过取地址操作符拿到的地址是一个数值，比如上方的 000000642F17FCD4 ，这个数值有时也是需要存储起来的，方便后期直接使用，而把这个地址值存储起来的变量就是——指针变量。

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

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

2.2.2 指针变量各部分理解

在 2.2.1 的代码中 p 左侧为int*，*是为了说明 p 是指针变量，int是为了说明 p 所指向的对象类型是int类型的。

int a = 4；
int * p = &a；

2.2.3 解引用操作符

我们既然将地址存储了下来，那后面要如何使用呢？这就涉及到了解引用操作符的使用。在C语言中，我们通过地址（指针）可以找到地址（指针）指向的对象，找地址指向的对象的这个过程就需要用到解引用操作符*。

#include<stdio.h>
int main()
{
    int a = 4;
    int* p = &a;//取出 a 的地址并存储到指针变量 p 中
    *p = 0;
    printf("经过指针修改后的 a 的值 = %d\n", a);
    return 0;
}

在上面的过程中可能会有人想，直接将a改为0不就好了？其实我们这么做只是为了演示改变数值大小可以有另外一条途径，使得编写更加灵活，具体可见本指针连更系列后续章节

2.3 指针变量大小

在文章开头x86系统中有32根地址总线，每根地址线电脉冲转换为数字信号后为1或0，我们吧32根地址线产生的2进制序列当成一个地址，那一个地址就是32个 bit 位，需要4个字节才能够存储。
同理在x64系统中就是64根地址线产生的2进制序列当成一个地址。那一个地址就是64个bit位，需要8个字节才能够存储。
注意：指针变量的大小与其类型是无关的，只要指针类型的变量在相同的平台下（x86/x64），大小都是相同的。

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

    return 0;
}

在x64系统下： 在x86系统下：

3.指针变量类型的意义

在 2.3 中我们知道了指针变量的大小和类型无关，只要是指针变量，在相同的平台（x86/x64），大小都是相同的。那么各类指针类型又是什么作用呢？

3.1 指针的解引用

代码一：

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

代码二：

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

在调试对比中发现代码一会将a的四个字节全部改为0，但是代码二只是将a的第一个字节改为0。由此我们总结出，指针的类型决定了对指针解引用时有多大的权限（访问几个字节）

3.2 指针±整数

#include<stdio.h>
int main()
{
    int n = 5;
    int* pi = &n;
    char* pc = (char*)&n;

    printf("%p\n", &n);
    printf("%p\n", pi);
    printf("%p\n", pi+1);
    printf("%p\n", pc);
    printf("%p\n", pc+1);
    return 0;
}

从上面运行中可以看出，int类型指针 + 1 跳过4个字节，char类型指针 + 1跳过1个字节。
指针的类型决定了指针向前或向后走一步有多大距离。

4.const修饰指针

4.1 const修饰变量

我们知道，变量是可以修改的，直接修改后者通过指针解引用来修改都是可行的。但我们若希望这个变量不被修改，就可以用const来进行修饰。

#include<stdio.h>
int main()
{
    int n = 0;
    n = 5;
    const int m = 1;
    m = 10;
    printf("%d", n);
    printf("%d", m);
    return 0;
}

上面代码运行时我们会发现出现了报错。这就是因为变量m被const修饰了，不可修改。
在这里补充一点，m 的本质还是变量，只不过用const修饰后使其具备了常属性，在C语言中我们称之为常变量。在C++中const修饰的变量就是常量了。
如果一定要修改，可以绕过m，而是使用m的指针来修改。虽然这样是在打破语法规则。

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

在上面的演示中我们不难会引发思考，用const修饰的变量本就是我们所不想被修改的。可我们通过pn拿到了n的地址进而对n进行了修改。所以我们下面要思考如何让pn拿到了n的地址也不能修改n。

4.2 const修饰指针变量

结论一：const 放在 * 的左侧，修饰的是指针指向的内容，保证了指针指向的内容不能被修改，但指针变量本身可以改变（即可以改变指针变量的指向）
结论二：const 放在 * 的右侧，修饰的是指针变量本身，保证了指针变量本身不能被修改（即指针变量不能再指向其余变量了），但指针指向的内容可以改变。
结论一代码验证：

#include<stdio.h>
int main()
{
    //const 修饰在 * 左侧
    int n = 0;
    const int* pn = &n;
 //   *pn = 20;加上这行代码则会出现报错
    int m = 0;
    pn = &m;
    return 0;
}

结论二代码验证：

#include<stdio.h>
int main()
{
    //const 修饰在 * 右侧
    int n = 0;
    int* const pn = &n;
    *pn = 20;
    int m = 0;
 //   pn = &m; 加上这行代码则会出现报错
    printf("%d", n);
    return 0;
}

5.指针运算

指针的基本运算有三种，分别是：
1.指针±整数
2.指针-指针
3.指针的关系运算（指针与指针比较大小也就是地址和地址比较大小）

5.1 指针 ± 整数

因为数组内元素地址是连续的，我们以数组为例。

#include<stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int* p = &arr[0];//将数组首元素地址存储到指针变量p中
    size_t sz = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    for (int i = 0; i < sz; i++)
    {
        printf("%d", *(p + i));//按照数组下标依次访问数组内元素
    }
    return 0;
}

在上面这段代码中，我们定义的数组是整型数组，故指针变量p后续所有的访问权限为4个字节，即*（p+1）跳过四个字节。
由此我们可以总结出：

5.2 指针-指针

我们知道日期-日期 = 中间的天数 ， 指针1 - 指针2 的绝对值 = 两地址之间的元素个数。（指针+指针和日期+日期一样，毫无意义）
指针 - 指针运算的前提条件：两指针必须指向同一块空间

#include<stdio.h>
int my_strlen(char* pa)//接收字符串数组abc的首元素a的地址
{
    char* p = pa;
    while (*p != '\0')
        p++;//当访问的字符串数组的元素不是\0时，指针p+1
    return p - pa;//将两个地址之间差多少传回主函数
}

int main()
{
    printf("%d", my_strlen("abc"));//将字符串数组传到自定义函数中
    return 0;
}

由上述代码我们可以计算出p与pa相差3个字节（p与pa都指向同一块空间字符串数组abc）

5.3 指针的关系运算

指针的关系运算也就是两指针之间比较大小，而比较大小又往往是作为判断条件所出现的。那么我们下面就用指针的关系运算来作为判断条件，进而打印数组。

#include<stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int* p = arr;//将整型数组的首元素地址赋值给p
    size_t sz = sizeof(arr) / sizeof(arr[0]);//计算数组长度
    while (p < arr + sz )//指针的关系运算——当指针p所指向的地址 < 数组首元素地址 + 数组长度时，循环进行。
    {
        printf("%d\n", *p);
        p++;//遍历数组元素
    }
    return 0;
}

6.野指针

野指针就是指针指向的位置是随机的（未知的）

6.1 为何会有野指针（成因）

6.1.1 指针未初始化

#include<stdio.h>
int main()
{   ///野指针
    int* p;//定义一个整型类型指针，不对其初始化
    *p = 20;//访问*p指向的空间，并对空间的内容修改为20；
    return 0;
}

一个局部变量若未初始化，默认存的是随机值。（在GCC编译器上会有警告，但在VS等集成开发环境上则不能运行）

6.1.2 指针越界访问

#include<stdio.h>
int main()
{
    int arr[10] = { 0 };
    int* p = arr;
    for (int i = 0; i <= 11; i++)//数组空间长度为10，i = 11时则会发生越界访问
    {
        *(p++) = i;//先解引用访问p的空间，内容修改为i，在++移动到下一处地址
    }
    return 0;
}

在上面这段代码中数组内部空间大小为10，而for循环所访问的空间大小为11，当访问完第十个元素进入到第十一次循环时，第十一次循环所访问的就是野指针。

6.1.3 指针指向空间的释放

#include<stdio.h>
int* test1()
{
    int n = 888;//定义局部变量n
    return &n;//将n的地址作为返回值传给调用部分
}
int main()
{
    int* p = test1();
    printf("%d", *p);//访问p所指向的空间内容
    return 0;
}

在上面这段代码中，自定义函数内的变量n为局部变量，其作用域与生命周期都局限于自定义函数内，当出了自定义函数后，操作系统会收回该部分栈空间，内容销毁。在主函数中想要去访问这部分空间时，由于这块空间已经被收回，所以指针变量p就等同于未进行初始化，形成野指针。

6.2 如何规避野指针

6.2.1 指针及时初始化

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

#include<stdio.h>
int main()
{
    int n = 0;
    int* p1 = &n;
    int* p2 = NULL;//赋值为NULL
    return 0;
}

6.2.2 野指针规避其余关注点

1 避免指针越界
2 指针使用前及时检查其有效性。指针不再使用时，及时赋值NULL
3 避免返回局部变量地址

7.assert断言

C语言assert.h头文件定义了宏assert（）用于在运行时确保程序符合指定条件，若不符合，就报错终止，这个宏常被称为“断言”。
比如在上文野指针内容中，我们要去判断这个指针已被初始化，空间内包含对应内容。我们就可以使用assert（p != NULL）;来断言。

assert（）优点：自动表示文件出问题的行号，还有一种无需更改代码就能开启或关闭assert的机制。若已经确认程序没有问题，就在#include<assert.h>语句的前面，定义一个宏#define NDEBUG。当程序又出现问题时，就把这个宏注释掉，如此就有可以启用assert（）语句了。
assert（）缺点：引入了额外的检查增加了程序的运行时间。

8.指针的使用和传址调用

8.1 指针的使用（strlen模拟实现）

strlen是C语言内的一个库函数，其功能是统计字符串中\0前的字符个数，返回值为\0前字符长度。
我们若想模拟实现它，只要从字符串起始位置开始逐步向后遍历，只要不是\0字符，计数就+1，直到访问的空间内容为\0停止。

#include<stdio.h>
#include<assert.h>
int my_strlen(const char* len)//形参指针len用于接受字符数组首地址
{
    int count = 0;//定义计数器count
    assert(len);//断言指针len，规避野指针
    for (  ; *len != 0; len++)//遍历字符串，当字符不等于0时循环进行，等于0时循环跳出
    {
        count++;//遍历一个字符，计数器+1
    }
    return count;//计数器的值作为返回值传回调用部分
}

int main()
{
    int lenth = my_strlen("abcdef");//将字符数组首地址传给形参
    printf("%d", lenth);
    return 0;
}

8.2 传值调用和传址调用

传值调用和传址调用，顾名思义，分别表示将数值传给形参和将地址传给形参。那二者有何不同呢？下面我们使用一个数值交换函数来体现。

//传值调用
#include<stdio.h>
void swap(int x, int y)
{
    int tmp = 0;//创建临时变量tmp，用于数值转换嫁接
    tmp = x;
    x = y;
    y = tmp;
}

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

上面这段程序就是传值调用，但数值真的交换了吗？

从结果可知，数值并未发上交换，这是为什么？
原因在于形参的实例化与局部变量的作用域与生命周期（这部分内容在先前函数详解博客中提及）。我们知道，形参在未进行实例化的时候是不会申请空间的，当形参实例化时，系统会为形参在单独开辟一段空间来临时拷贝实参，出生命周期后系统收回，故在这种情况下形参的修改不会影响实参。所以上面的传值调用的结果未发生交换。但有一种情况例外，那就是传址调用。

//传址调用
#include<stdio.h>
void swap(int* pa, int* pb)//创建两个形参指针用于接收a与b的地址
{
    int tmp = 0;//创建临时变量tmp，用于数值转换嫁接
    tmp = *pa;//解引用进行数值交换
    *pa = *pb;
    *pb = tmp;
}

int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    printf("交换前：a = %d\n b = %d\n", a, b);
    swap(&a, &b);//将a和b的地址作为实参传给形参
    printf("交换后：a = %d\n b = %d\n", a, b);
    return 0;
}

可见，传址调用完成了数值交换。这是因为在主函数中我们将变量a与b的地址作为实参传给了形参，如此一来，自定义函数中所操作的空间不再是单独开辟的空间，而是间接的由形参访问到的a与b的内容，数值的交换是通过地址进行操作的。即实参与形参共用了同一块空间，从而完成了数值交换。
由上8.2我们可以总结出：传址调用，可以让自定义函数与主函数建立真正的联系，在自定义函数内部可以主函数内部的变量。故若自定义函数中只是需要主函数内的数值来完成相应计算，就可以采用传值调用。若自定义函数内部需要修改主函数内部变量的值，就需要采用传址调用。

全文至此结束！！！
写作不易，不知各位老板能否给个一键三连或是一个免费的赞呢(-▽-)(-▽-)，这将是对我最大的肯定与支持！！！谢谢！！！(-▽-)(-▽-)