目录
6.2.3 指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性
指针在编程中扮演着至关重要的角色，首先，指针是内存的标签，通过它我们可以定位到内存中的特定位置。这种能力允许程序员直接操作内存地址，从而增加了编程的灵活性和效率。
1. 内存和地址
1.1 内存
计算机上CPU（中央处理器）在处理数据时，需要的数据在内存中读取，处理后的数据又存放回内存。为了高效管理内存空间，把内存划分为一个个内存单元，每个内存单元大小取1个字节。每个内存单元都有一个编号（也称地址），有了这个内存单元的编号，CPU就可以快速找到一个内存空间。C语言中给这个地址取名“指针”。
1.2 如何理解编址
CPU访问内存中的某个字节空间，必须知道这个字节空间在内存中的位置，因为内存中字节很多，所以需要给内存编址。
计算机中编址，不是把每个字节的地址记录下来，二是通过硬件设计完成。硬件编址是一种约定俗成的共识！
计算机内众多硬件单元相互协同工作，为了进行数据传输需要线连接，CPU和内存之间有大量的数据交互。今天要提的是地址总线，它是一种计算机总线，是CPU或有DMA能力的单元，用来沟通这些单元想要访问（读取/写入）计算机内存组件/地方的物理地址。32位机器有32根地址总线， 每根线只有两态，表示 0,1（电脉冲有无），一根线，就能表示2种含义，2根线就能表示4种含义，依次类推。32根地址线，就能表示2^32种含义，每⼀种含义都代表一个地址。
地址信息被下达给内存，在内存上，就可以找到 该地址对应的数据，将数据在通过数据总线传入 CPU内寄存器。
2. 指针变量和地址
2.1 取地址操作符 &
在C语言中创建变量就是向内存申请空间，例如：
#include <stdio.h>
int main()
{
int a = 10;
return 0;
}上述代码创建了整型变量 a , 内存中申请了4个字节，用于存放整数10，其中每个字节都有地址。
为了获取a的地址就得使用一个操作符(&)——取地址操作符。
#include <stdio.h>
int main()
{
int a = 10;
&a;//取出a的地址
printf("%p\n", &a);
return 0;
}&a取出的是a所占4个字节中地址较小的字节的地址，因为整型变量占用4个字节，所以只要知道了第一个字节地址，访问到4个字节的数据也是可行的。
2.2 指针变量和解引用操作符 *
2.2.1 指针变量
通过取地址操作符 & 拿到的地址是一个数值，这个数值有时候需要存储起来，方便后期再使用所以要把它存放在“ 指针变量 ”中。例如：
#include <stdio.h>
int main()
{
int a = 10;
int * pa = &a;//取出a的地址并存储到指针变量pa中
printf("%p\n", &a);
return 0;
}指针变量也是一种变量，这种变量用来存放地址，存放在指针变量中的值都会被理解为地址。
2.2.2 拆解指针类型
1 int a = 10;
1 int * pa = &a;
int *中 * 表示 pa 是指针变量，int 表示 pa 指向的是整型 int 类型的对象。
char类型则表示为：
1 char ch = ' w ';
2 pc = &ch;
2.2.3 解引用操作符
地址保存后未来需要使用，拿到了地址（指针），可以通过地址（指针）找到地址（指针）指向的对象，这里要提到⼀个操作符——解引用操作符*。
#include <stdio.h>
int main()
{
int a = 100;
int * pa = &a;
*pa = 0;
return 0;
}第7行 *pa 表示通过pa中存放的地址，找到指向的空间，*pa其实就是变量a；所以*pa=0表示把a改成了0。a的地址还是原地址，只是值被改了。
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 *));
}
x86环境输出结果
x64环境输出结果
因此，32位平台下地址是32个bit位，指针变量大小是4个字节；64位平台下地址是64个bit位，指针变量大小是8个字节。注意，指针变量的大小和类型无关，只要是指针类型的变量，在相同的平台下，大小都是相同的。
3. 指针变量类型的意义
3.1 指针的解引用
#include <stdio.h>
//代码1
int main()
{
int n = 0x11223344;
int* pi = &n;
*pi = 0;
return 0;
}#include <stdio.h>
//代码2
int main()
{
int n = 0x11223344;
char *pc = (char *)&n;
*pc = 0;
return 0;
}通过调试以上两段代码，观察其内存变化可得代码1会将n的4个字节全部改为0，代码2只会将n的第一个字节改为0。
结论：指针的类型决定了对指针解引用的时候有多大的权限（一次能操作几个字节）。例如：char*的指针解引用只能访问一个字节，int* 的指针解引用能访问四个字节。
3.2 指针+-整数
char* 类型的指针变量+1跳过1个字节，int*类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。
结论：指针的类型决定了指针向前或者向后走一步有多大距离。
3.3 void *指针
在指针类型中有一种特殊的类型是void*类型的，可理解为无具体类型的指针（或者叫泛型指
针），这种类型的指针可用来接受任意类型地址。但也有局限性，void*类型的指针不能直接进行
指针的+-整数（大小未知）和解引用运算。
一般 void* 类型的指针使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果，实现个函数来处理多种类型的数据。
4. const 修饰指针
4.1 const 修饰变量
变量可以修改，如果把变量的地址交给一个指针变量，通过指针变量也可以修改这个变量。但如果希望一个变量加上一些限制，不能被修改，就要使用const。例如：
#include <stdio.h>
int main()
{
int a = 0;
a = 10;//a可修改
const int b = 0;
b = 30;//b不可修改
return 0;
}上述代码中b不能被修改，b本质是变量，只不过被const修饰后，在语法上加了限制，只要在代码中对b进行修改，就不符合语法规则，报错致使没法直接修改b。
4.2 const 修饰指针变量
4.1 中如果绕过变量b，使用b的地址就可以修改b，虽然这是在打破语法规则，但是确实可以修改。但 b被const修饰就是为了不能被修改，所以应该拿到b的地址也不能被修改。这时，就要注意const的位置。
结论：const修饰指针变量时，
- const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本身的内容可变。
- const如果放在*的右边，修饰的是指针变量本身 ，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。
5.指针运算
指针的基本运算有三种，分别是：
- 指针+-整数
- 指针-指针
- 指针的关系运算
5.1 指针+-整数
数组在内存中是连续存放的，只要知道第一个元素的地址，就能找到后面的所有元素。
#include <stdio.h>
//指针+-整数
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 < sz; i++)
{
printf("%d", *(p + i));//p+i就是指针+整数，这里加的是i*sizeof(int)
}
return 0;
}5.2 指针-指针
#include <stdio.h>
//指针-指针=地址-地址，得到的是指针和指针之间元素的个数
int my_strlen(char *s)
{
char *p = s;
while (*p != '\0')
p++;
return p - s;
}
int main()
{
printf("%d\n", my_strlen("abc"));
return 0;
}5.3 指针的关系运算
即指针（地址）比较大小
#include <stdio.h>
//指针的关系运算
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]);//arr是数组名，数组名即数组首元素地址
while (p < arr + sz)//指针大小比较
{
printf("%d", *p);
p++;
}
return 0;
}6.野指针
野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）。
6.1 野指针成因
1.指针未初始化
局部变量不初始化，变量值随机。全局变量和静态变量不初始化，变量值默认是0（静态区）。
2.指针访问越界
#include <stdio.h>
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;
}3.指针指向的空间释放
#include <stdio.h>
int* test()
{
int n = 100;
return &n;
}
//n已被销毁
int main()
{
int* p = test();
printf("%d\n", *p);
return 0;
}6.2 如何规避野指针
6.2.1 指针初始化
若明确知道指针指向哪里就直接赋值地址，不知道指针应该指向哪里，可以给指针赋值NULL。NULL是C语言中定义的一个标识符常量，值是0，0也是地址，这个地址无法使用，读写该地址会报错。
6.2.2 小心指针越界
一个程序向内存申请了哪些空间，通过指针就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。
6.2.3 指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性
当指针变量指向一块区域的时候，可以通过指针访问该区域，后期不再使用这个指针访问空间的时，可以把该指针置为NULL。因为约定俗成的一个规则就是：只要是NULL指针就不去访问，同时所以指针之前可以判断指针是否为NULL。
指针在使⽤之前，也要判断是否为NULL，如果是，不能直接使⽤，如果不是，才能使用。
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[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 避免返回局部变量的地址
C语言中，局部变量的作用域被限定在其所在的函数或代码块内。当函数执行完毕或代码块结束时，这些局部变量所占用的内存会被系统自动回收。因此，如果尝试返回局部变量的地址或引用，由于该局部变量在函数返回后已经被销毁，此时引用或指针将指向一个无效或不可预知的内存区域，进而导致程序运行出错或产生未知行为。
总之，避免返回局部变量的地址或引用是为了确保程序的稳定性和安全性，防止因试图访问已释放的内存空间而导致的程序错误。
7. assert 断言
assert.h 头文件定义了宏 assert() ，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。
1 assert (p !=NULL);
上面代码在程序运行到这一行语句时，验证变量p是否等于NULL。如果不等于NULL，程序继续运行，否则终止运行，并且给出报错信息提示。
assert()宏接受一个表达式作为参数。如果表达式为真（返回值非零），assert()不会产生任何作用，程序继续运行。如果该表达式为假（返回值为零），assert()就会报错，在标准错误流stderr中写入一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。
它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭assert()的机制。如果已经确认程序没有问题，不需要再做断言，就在#include 语句的前面，定义一个宏NDEBUG。
1 #define NDWBUG
2 #include <assert.h>
然后，重新编译程序，编译器就会禁用文件中所有的assert()语句。如果程序又出现问题，可以移除这条 #define NDBUG指令（或者把它注释掉），再次编译，这样就重新启用了assert()语句。
assert()的缺点是引入了额外的检查，增加了程序的运行时间。一般在Debug中使用，有利于程序员排查问题，在Release版本中选择禁用assert。在VS这样的集成开发环境中，Release版本中的assert直接被优化了。
8.指针的使用和传址调用
8.1 strlen 的模拟实现
库函数strlen的功能是求字符串长度，统计的是字符串中\0之前的字符的个数。
函数原型为：
1 size_t strlen ( const char * str ); //%zd,无符号整型
参数str接收一个字符串的起始地址，然后开始统计字符串中\0之前的字符个数，最终返回长度。
模拟实现该函数只要从起始地址开始向后逐个字符的遍历，只要不是\0字符，计数器就+1，直到\0就停止。
代码如下：
#include <stdio.h>
#include<assert.h>
int my_strlen(const char* str)
{
int count = 0;
assert(str);
while (*str)
{
count++;
str++;
}
return count;
}
int main()
{
int len = my_strlen("abcdef");
printf("%d\n", len);
return 0;
}8.2 传值调用和传值调用
传值调用函数时，函数的实参传给形参时，形参是实参的一份临时拷贝，形参有自己的独立空间，对形参的修改不会影响实参。
写一个函数，交换两个整型变量的值，用传值调无法做到，这里使用指针传址调用来实现：
#include <stdio.h>
#include<assert.h>
void Swap(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 n=%d\n", a, b);
Swap(&a, &b);
printf("交换后：a=%d n=%d\n", a, b);
return 0;
}
传址调用可以让函数和主调函数之间建立真正的联系，在函数内部可以修改主调函数中的变量。所以，函数中只需要主调函数中的变量值来实现计算，可以采用传值调用。如果函数内部要修改主调函数中的变量的值，需要传址调用。
总结
指针在C语言中的地位非常重要，它是最基础和最重要的概念之一。指针的存在让C语言可以进行复杂的内存操作，更好地控制程序的行为，同时也能够实现高效的数据结构和算法。
通过指针能实现所谓的“传引用”而不是“传值”，这在函数参数传递时可以有效地改变参数的值，而不仅仅是复制一份参数的值，从而在本质上节约了数据传输性能。其次，C语言支持指针的运算（对指针加减，甚至取指针），这是C语言强大的地方。同时，指针也用于表示和实现各种复杂的数据结构，比如系统地动态分配内存、消息机制、任务调度等。此外，利用指针可以直接操纵内存地址，从而可以完成和汇编语言类似的工作。
需要注意的是，指针是一个强大但同时也是比较危险的工具。如果不正确使用指针，比如误操作空指针，可能会导致程序崩溃或者产生其他错误。因此，学习和使用指针需要谨慎对待。总的来说，指针在C语言中的地位不可替代，掌握好指针的使用是学习C语言的关键之一。
898
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
