指针的奥秘（一）：指针概念+指针类型+指针运算+野指针

2024-06-04 8188阅读

指针

一.内存和地址
- 1.内存
- 2.编址
- 二.指针变量和指针
- - 1.取地址操作符（&）
  - 2.指针变量和解引用操作符（*）
  - - 1.指针变量
    - 2.拆解指针类型
    - 3.解引用操作符
    - 4.指针变量的大小
    - 三.指针变量的类型和意义
    - - 1.指针的解引用
      - 2.指针 +- 整数
      - 3.void* 指针
      - 四.const修饰指针
      - 1.const修饰变量
        2.const修饰指针变量
        五.指针运算
        1.指针 +- 整数
        2.指针 - 指针
        3.指针的关系运算
        六.野指针
        1.野指针成因
        1.指针未初始化
        2.指针越界访问
        3.指针指向的空间释放
        2.如何规避野指针
        1.指针初始化
        2.小心指针越界
        3.避免返回局部变量的地址
        4.指针变量不再使用时置为NULL，指针使用之前检查有效性
        七.assert断言
        前言：
        一谈到指针，大家的印象都是非常的难，但是指针对于C语言的学习是至关重要的，有了指针的基础，对于以后学习数据结构有很大的帮助，这是一个承上启下的过程，但是如果指针没有学好的话，学习数据结构是相当吃力地，即便是最简单的顺序表，链表。
        对于指针的学习，首先是不能畏惧指针，你若害怕一件事，那么迎接你的大概是你最不希望看到的，生活也是如此。所以要有一种迎难而上的精神，要对自己充满信心，抱着一定能学好指针的态度，即便过程艰辛但结局完美，也不辜此行。
        那么从现在开始，行动起来吧，自信的你才是最完美的自己！
        一.内存和地址
        
        1.内存
        
        在理解指针之前我们需要知道计算机中的内存分配。
        
        计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存有8GB/16GB/32GB等，那这些内存空间如何高效的管理呢？
        其实计算机把内存划分为⼀个个的内存单元，每个内存单元的大小为1个字节。
        将内存比作学校，内存单元就好比⼀个个教室，⼀个字节空间里面能放8个比特位，就好比教室里只能存在8个人，每个人是⼀个比特位。每个内存单元也都有⼀个编号（这个编号就相当于教室的门牌号），有了这个内存单元的编号，CPU就可以快速找到这个内存空间（教室）。生活中我们把门牌号也叫地址，在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起了新的名字叫：指针。
        
        所以我们可以理解为：内存单元的编号 == 地址 ==指针
        
        
        2.编址
        
        CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址(就如同教室很多，需要给教室编号⼀样)。
        计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。
        首先，必须理解，计算机内是有很多的硬件单元，而硬件单元是要互相协同工作的。所谓的协同，至少相互之间要能够进行数据传递。但是硬件与硬件之间是互相独立的，那么如何通信呢？答案很简单，用"线"连起来。而CPU和内存之间也是有⼤量的数据交互的，所以，两者必须也用线连起来。不过，我们今天关心⼀组线，叫做地址总线。
        我们可以简单理解，32位机器有32根地址总线，每根线只有两中状态，表示0,1【电脉冲有无】，⼀根线，能表示2种含义，2根线就能表示4种含义，依次类推。32根地址线，就能表示2 ^ 32种含义，每⼀种含义都代表⼀个地址。所以32位机器共有2 ^ 32个地址。
        地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。
        二.指针变量和指针
        
        1.取地址操作符（&）
        
        在C语⾔中创建变量其实就是向内存中的栈区申请空间，比如，上述的代码就是创建了整型变量a，向内存中申请4个字节，用于存放整数10，其中每个字节都有地址，上图中4个字节的地址分别是：0x00CFF9C,0x00CFF9D,0x00CFF9E,0x00CFF9F。
        按照我画图的例子，会打印处理：0x00CFF9C。&a取出的是a所占4个字节中地址较小的字节的地址。虽然整型变量占用4个字节，我们只要知道了第⼀个字节地址，顺藤摸瓜访问到4个字节的数据也是可行的。
        2.指针变量和解引用操作符（*）
        
        1.指针变量
        
        #include int main() { int a = 10; int* pa = &a;//取出a的地址并存储到指针变量pa中 return 0; }
        
        那我们通过取地址操作符(&)拿到的地址是⼀个数值，比如：0x0012FF40，这个数值有时候也是需要存储起来，方便后期再使用的，那我们把这样的地址值存放在哪⾥呢？答案是：指针变量中。如图：
        
        指针变量也是⼀种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。
        我们口头说的指针是指针变量。
        2.拆解指针类型
        
        #include int main() { int a = 10; int * pa = &a; return 0; }
        
        我们看到pa的类型是 int* ，我们该如何理解指针的类型呢？如图：
        
        3.解引用操作符
        
        #include int main() { int a = 100; int* pa = &a; *pa = 0; printf("%d\n", a);//输出0 return 0; }
        
        *pa表示什么意思呢？如图：
        
        通过指针来修改，指针所指向的内容，就多了一种途径，体现出代码的灵活，那到底为什么要这样做呢？跟着我将指针学完，你就懂了。
        4.指针变量的大小
        
        #include //指针变量的大小取决于地址的大小 //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; }
        
        结论：
        
        32位平台下（x86）地址是32个bit位，指针变量大小是4个字节。
        64位平台下（x64）地址是64个bit位，指针变量大小是8个字节。
        注意：指针变量的大小和类型是无关的，指针类型的变量，在相同的平台下，大小都是相同的。
        三.指针变量的类型和意义
        
        1.指针的解引用
        
        以下给出两类代码，理解指针变量类型的意义
        代码1：
        
        #include int main() { int n = 0x11223344; int *pi = &n; *pi = 0; return 0; }
        
        调试我们可以看到，代码1会将n的4个字节全部改为0。
        代码1：
        
        #include int main() { int n = 0x11223344; char* pc = (char*)&n; *pc = 0; return 0; }
        
        调试我们可以看到，代码2只是将n的第⼀个字节改为0。
        结论：
        
        指针的类型决定了，对指针解引用的时候有多大的权限（⼀次能操作（访问）几个字节）。比如： char* 的指针解引用就只能访问⼀个字节，而 int* 的指针的解用就能访问四个字节。这就是代码1与代码2不同的根本原因。
        2.指针 ± 整数
        
        先来一段代码，观察地址的变化
        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个字节。这就是指针变量的类型差异带来的变化。指针+1，其实跳过指针指向的元素的类型的大小（字节数）。指针可以+1，那也可以-1。
        结论：
        
        指针的类型决定了指针向前或者向后走一步有多大（距离）。
        3.void* 指针
        
        在指针类型中有⼀种特殊的类型是 void * 类型的，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进行指针的±整数和解引用的运算。
        因为不知道一次访问/跳过多少个字节，但是可以先强制类型转换，再进行指针的±整数和解引用的运算。
        ⼀般 void* 类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。由于这篇文章是初识指针，这一部分放在之后讲解。
        四.const修饰指针
        
        1.const修饰变量
        
        变量是可以修改的，但是如果我们希望⼀个变量加上一些限制，不能被修改，怎么做呢？这就是const的作用。
        #include int main() { int m = 0; m = 20;//m是可以修改的 const int n = 0; n = 20;//n是不能被修改的 return 0; }
        
        上述代码中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; }
        
        我们可以看到这里⼀个确实修改了，但是我们还是要思考⼀下，为什么n要被const修饰呢？就是为了不能被修改，如果p拿到n的地址就能修改n，这样就打破了const的限制，这是不合理的，所以应该让p拿到n的地址也不能修改n，那接下来怎么做呢？于是就有了const修饰指针变量。
        2.const修饰指针变量
        
        ⼀般来讲const修饰指针变量，可以放在 * 的左边，也可以放在 * 的右边，也可以放在两边，意义是不⼀样的。以下为三种可能代码：
        int* p//没有const修饰 int const *p//const 放在*的左边做修饰等价于const int *p int* const p//const 放在*的右边做修饰 int const * const p //const 放在*的左右两边做修饰
        
        我们看下面代码，来分析具体分析⼀下：
        #include //代码1 - 测试⽆const修饰的情况 void test1() { int n = 10; int m = 20; int* p = &n; *p = 20;//ok p = &m; //ok } //代码2 - 测试const放在*的左边情况 void test2() { int n = 10; int m = 20; const int* p = &n; *p = 20;//err p = &m; //ok } //代码3 - 测试const放在*的右边情况 void test3() { int n = 10; int m = 20; int* const p = &n; *p = 20; //ok p = &m; //err } //代码4 - 测试*的左右两边都有const void test4() { int n = 10; int m = 20; int const* const p = &n; *p = 20; //err p = &m; //err } int main() { //测试⽆const修饰的情况 test1(); //测试const放在*的左边情况 test2(); //测试const放在*的右边情况 test3(); //测试*的左右两边都有const test4(); return 0; }
        
        const修饰指针变量的时候的结论：
        
        无const修饰的指针：指针变量本身的内容可变，指针指向的内容，也可以通过指针改变。
        const如果放在 * 的左边：修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本身的内容可变。
        const如果放在 * 的右边：修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。
        const如果放在 * 的左右两边：保证了指针变量的内容不能修改，以及保证指针指向的内容不能通过指针来改变。
        五.指针运算
        
        1.指针 ± 整数
        
        由于数组在内存中是连续存放的，只要知道第⼀个元素的地址，顺藤摸瓜能找到后面的所有元素。如何表示呢？如下：
        #include //指针+- 整数 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
        p指向整形元素arr[0]，p+1跳过4个字节，也就是1个整形，所以p+1指向整形元素arr[1]。
        p一次访问4个字节，也就是一个整形，得到arr[0]。
        同理*(p+1)得到arr[1]，按照指针的方法就可以打印数组所有的元素。
        其实：arr[0]本质就是*(p+0), arr[i]==*(p+i)。
        还有：数组名arr就是首元素的地址，也就是arr[0]的地址，也可以这么写，arr[0]等价于* (arr+0), arr[i]等价于* (arr+i)。
        2.指针 - 指针
        
        大指针 - 小指针得到的是指针之间元素的个数，仅限于它们是同一块空间还有小指针 - 大指针得到的就是负数。例如：
        #include //指针 - 指针 int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int* p1 = &arr[0]; int* p2 = &arr[6]; printf("%d\n", p1 - p2);//-6 printf("%d\n", p2 - p1);//6 return 0; }
        
        数组再内存中是连续存放的，且是由低地址向高地址存放的。
        3.指针的关系运算
        
        指针还能够比较大小，指针本质是地址，地址以16进制显现出来的，所以本质就是比较两个数的大小。
        #include int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int* p = &arr[0]; int sz = sizeof(arr) / sizeof(arr[0]); while (p
        六.野指针
        
        概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的），是非常危险的。
        1.野指针成因
        
        1.指针未初始化
        
        //1.指针未初始化 #include int main() { int* p;//局部变量指针未初始化，没有明确的指向，默认为随机值 *p = 20;//非法访问内存了，p就是野指针 //随机将p指向的对象改变是非常危险的，这是错误的做法 return 0; }
        
        2.指针越界访问
        
        //2.指针越界访问 #include int main() { int arr[10] = { 0 }; int* p = &arr[0]; int i = 0; for (i = 0; i //当指针指向的范围超出数组arr的范围时，p就是野指针 //我们没有权限访问及修改，这片空间 *(p++) = i; } return 0; } int a = 10; return &a; } int main() { int* p = test(); //p中存着a的地址，a已经还给操作系统了，p不能使用这块空间，p就是野指针 //但是内存里的这块空间还在，只是不属于当前程序，没有使用着块空间的使用权限 printf("%d\n", *p);//通过非法的地址，如果这块空间没有被使用（覆盖），还能找到10，但是不属于我们。 return 0; } int num = 10; int* p1 = &num; int* p2 = NULL; return 0; } int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int* p = &arr[0]; int i = 0; for (i = 0; i

指针的奥秘（一）：指针概念+指针类型+指针运算+野指针

指针

一.内存和地址

1.内存

2.编址

二.指针变量和指针

1.取地址操作符（&）

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

1.指针变量

2.拆解指针类型

3.解引用操作符

4.指针变量的大小

三.指针变量的类型和意义

1.指针的解引用

2.指针 ± 整数

3.void* 指针

四.const修饰指针

1.const修饰变量

2.const修饰指针变量

五.指针运算

1.指针 ± 整数

2.指针 - 指针

3.指针的关系运算

1.野指针成因

1.指针未初始化

2.指针越界访问

相关阅读

Linux VPS端口转发状态查看指南，轻松掌握转发状态！

揭秘抓鸡扫爆VPS行动，背后真相大揭秘！

VPS在FX交易中的应用，探索最佳实践策略，助力高效交易！

VPS一键去广告，告别烦恼，轻松畅享网络！

目录[+]

指针

一.内存和地址

1.内存

2.编址

二.指针变量和指针

1.取地址操作符（&）

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

1.指针变量

2.拆解指针类型

3.解引用操作符

4.指针变量的大小

三.指针变量的类型和意义

1.指针的解引用

2.指针 ± 整数

3.void* 指针

四.const修饰指针

1.const修饰变量

2.const修饰指针变量

五.指针运算

1.指针 ± 整数

2.指针 - 指针

3.指针的关系运算

六.野指针

1.野指针成因

1.指针未初始化

2.指针越界访问

相关阅读

Linux VPS端口转发状态查看指南，轻松掌握转发状态！

揭秘抓鸡扫爆VPS行动，背后真相大揭秘！

VPS在FX交易中的应用，探索最佳实践策略，助力高效交易！

VPS一键去广告，告别烦恼，轻松畅享网络！

目录[+]