深入理解指针（1）（C语言版）

前言

在C语言中，指针是一个非常重要且强大的概念。它允许程序员直接操作内存，从而实现高效的数据处理和灵活的程序控制。然而，指针也是C语言中较为复杂和容易出错的部分。深入理解指针的原理和用法，对于每一个C语言开发者来说都至关重要。本篇博客将从内存和地址的基本概念入手，逐步深入探讨指针变量、指针类型、指针运算、野指针以及指针在函数传址调用中的应用等内容。

一、内存和地址

1.1 内存

计算机的内存就像一个巨大的仓库，里面有很多很多的小格子，每个小格子都可以用来存放数据。这些小格子的大小和用途各不相同，有的可以存放整数，有的可以存放字符，还有的可以存放浮点数等等。

假设你有一个超市的货架，货架上有很多层，每一层都有很多个格子，每个格子都可以用来存放商品。这些格子的大小和用途各不相同，有的可以存放大型商品，如家电；有的可以存放中型商品，如食品；还有的可以存放小型商品，如化妆品。当你需要存放或者取用某样商品的时候，你只需要知道对应的格子位置，就可以直接找到那个格子。

在计算机中，内存被划分成一个个小的存储单元，每个单元都有一个唯一的编号，这个编号就是内存地址。这些存储单元可以用来存放各种各样的数据，比如数字、文字、图片等等。通过内存地址，程序可以访问和操作特定存储单元中的数据。

举个例子，假设我们有一个变量 num，它的值是10。编译器会为这个变量分配一个内存地址，比如说 0x7ffee5e0。这个内存地址就像是 num 这个变量在内存仓库里的格子位置。我们可以用这个格子位置来找到这个变量的值，就像用货架上的格子位置找到对应的商品一样。

1.2 究竟该如何理解编址

编址就像是给内存仓库里的每个格子分配一个唯一的门牌号。通过这个门牌号，我们可以准确地找到每个格子的位置，从而进行数据的存取操作。

在现实生活中，我们经常需要通过地址来找到某个地方。比如，你想要去一个朋友的家里，你需要知道他家的详细地址，包括城市、街道、门牌号等。只有这样，你才能准确地找到他的家。同样地，在计算机中，通过内存地址，程序可以准确地找到对应的存储单元。

内存地址通常以十六进制形式表示，例如 0x7ffee5e0。每个内存地址对应一个存储单元，存储单元的大小由数据类型决定。例如，一个 int 类型的变量通常占用4个字节的内存空间，这意味着它需要连续的4个存储单元。

举个例子，假设我们有一个数组 arr，它包含5个整数。编译器会为这个数组分配连续的内存空间，每个整数占用4个字节。数组的首地址是 0x7ffee5e0，那么数组中各个元素的地址如下：

• arr[0] 的地址是 0x7ffee5e0
• arr[1] 的地址是 0x7ffee5e4
• arr[2] 的地址是 0x7ffee5e8
• arr[3] 的地址是 0x7ffee5ec
• arr[4] 的地址是 0x7ffee5f0

通过这种方式，程序可以按照一定的规则访问数组中的每个元素。

在程序中，我们经常需要通过指针来操作内存地址。指针变量存储的是内存地址，通过指针可以间接访问该地址中的数据。这就像通过朋友家的门牌号找到他的家，然后进行拜访一样。

通过这样的类比，我们可以更直观地理解内存和编址的概念。内存就像是一个巨大的仓库，被划分成一个个小的存储单元，每个单元都有一个唯一的地址。编址就是给这些单元分配门牌号，方便程序进行数据的存取操作。这种机制使得程序能够高效地管理和操作数据，为后续的指针操作奠定了基础。

二、指针变量和地址

2.1 取地址操作符&

在C语言中，& 符号被称为取地址操作符。它的作用是获取一个变量在内存中的地址。这就像我们通过地图应用获取某个地点的坐标一样。

举个例子，假设我们有一个变量 num，它的值是10。我们可以通过 &num 获取它的内存地址。

int num = 10;
printf("num的地址是：%p", &num);

在这个例子中，&num 获取了变量 num 的内存地址，并通过 printf 函数输出。%p 是用于打印内存地址的格式说明符。

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

2.2.1 指针变量

指针变量是一种特殊的变量，它存储的是内存地址。我们可以把指针变量想象成一个快递单号，快递单号本身并不包含商品，但它能告诉你商品存放在哪个仓库的哪个位置。

int num = 10;
int *p; // 声明一个指针变量p，它可以存储int类型的内存地址
p = # // 将num的地址赋值给指针变量p

在这个例子中，p 是一个指针变量，它保存了变量 num 的内存地址。

2.2.2 如何拆解指针类型

指针变量是有类型的，它决定了指针所指向的数据的类型和大小。指针类型需要与所指向的数据类型匹配，这样编译器才能正确地进行内存操作。

一个指针类型的声明可以拆解为以下几个部分：

• 指针所指向的数据类型（如 int、float、char 等）
• 指针本身的类型（* 表示这是一个指针）

例如，int *p; 表示 p 是一个指向 int 类型数据的指针。

2.2.3 解引用操作符

* 符号除了用于声明指针变量外，还用于解引用操作。解引用操作符的作用是获取指针所指向的内存单元中的值。这就像我们通过快递单号找到商品所在的仓库位置，然后取出商品一样。

printf("%d", *p); // 输出10，即num的值

在这个例子中，*p 表示获取指针 p 所指向的内存单元中的值，也就是变量 num 的值。

2.3 指针变量的大小

指针变量的大小取决于计算机系统的架构。在32位系统中，指针变量通常占用4个字节；在64位系统中，指针变量通常占用8个字节。这是因为32位系统使用32位（4字节）的内存地址，而64位系统使用64位（8字节）的内存地址。

printf("指针变量的大小是：%zu字节", sizeof(p));

在这个例子中，sizeof(p) 获取了指针变量 p 的大小，并通过 printf 函数输出。%zu 是用于打印大小的格式说明符。

通过这样的类比和解释，我们可以更直观地理解指针变量和地址的概念。指针变量就像是快递单号，它本身并不包含数据，但它能告诉你数据存放在内存的哪个位置。通过取地址操作符 &，我们可以获取变量的内存地址；通过解引用操作符 *，我们可以访问指针所指向的内存单元中的值。这种机制使得程序能够灵活地操作内存中的数据。

三、指针变量类型的意义

3.1 指针的解引用

指针的解引用操作符 * 用于获取指针所指向的内存单元中的值。这就像我们通过快递单号找到商品所在的仓库位置，然后取出商品一样。

int num = 10;
int *p = # // p是int类型的指针，指向num的地址
printf("%d", *p); // 输出10，即num的值

在这个例子中，*p 表示获取指针 p 所指向的内存单元中的值，也就是变量 num 的值。通过解引用，我们可以访问和操作指针所指向的数据。

3.2 指针±整数

指针支持与整数进行加法和减法运算。这在遍历数组或处理连续内存块时非常有用。指针与整数相加或相减时，会根据指针的类型自动计算偏移量。

int arr[5] = {1, 2, 3, 4, 5};
int *p = arr; // p指向数组的第一个元素for (int i = 0; i < 5; i++) {printf("%d ", *p); // 输出数组元素的值p++; // 指针自增，指向下一个元素
}

在这个例子中，p 是一个指向 int 类型的指针，初始时指向数组的第一个元素。通过指针自增运算，我们可以遍历整个数组。每次自增操作都会使指针移动到下一个元素的位置。

3.3 void*指针

void* 是一种通用指针类型，它可以指向任何类型的数据。void* 指针不与任何特定的数据类型关联，因此在使用时需要进行类型转换。

int num = 10;
void *p = # // p是一个void类型的指针，指向num的地址// 要访问指针所指向的值，需要进行类型转换
printf("%d", *(int*)p); // 输出10，即num的值

在这个例子中，p 是一个 void* 指针，它指向了 num 的地址。由于 void* 指针不与任何特定的数据类型关联，所以在访问它所指向的值时，需要将其转换为具体的指针类型（如 int*），然后进行解引用操作。

通过理解指针变量类型的意义，我们可以更灵活地使用指针进行内存操作。指针的解引用允许我们访问指针所指向的数据，指针与整数的运算使得遍历数组等操作更加方便，而 void* 指针则提供了一种通用的指针类型，适用于多种场景。这些特性使得指针在C语言中非常强大和灵活。

四、const修饰指针

4.1 const修饰变量

const 关键字用于声明常量，表示该变量的值在声明后不能被修改。这就像我们去博物馆参观展品，这些展品是受到保护的，我们只能观看，不能触摸或改变它们。

const int num = 10; // 声明一个常量num，值为10
// num = 20; // 错误：不能修改常量的值

在这个例子中，num 被声明为一个常量，它的值在程序运行过程中不能被修改。

4.2 const修饰指针变量

const 修饰指针变量时，可以有以下两种情况：

4.2.1 指针指向的数据是常量

const 修饰指针指向的数据，表示不能通过该指针修改所指向的数据。这就像我们拿到了一份只读的文件，我们可以查看文件内容，但不能修改它。

const int *p; // p是一个指向常量int的指针，不能通过p修改它所指向的int值

int num = 10;
const int *p = # // p指向num的地址
// *p = 20; // 错误：不能通过const指针修改数据

在这个例子中，p 是一个指向常量 int 的指针，不能通过 p 修改它所指向的 int 值。

4.2.2 指针本身是常量

const 修饰指针本身，表示指针的值（即它所存储的内存地址）不能被修改。这就像我们拿到了一张电影票，票上的座位号是固定的，我们不能随意更换座位。

int *const p; // p是一个const指针，即指针本身是常量，不能改变它所指向的地址

int num = 10;
int *const p = # // p被初始化为指向num的地址
// p = &another_num; // 错误：不能修改const指针的值

在这个例子中，p 是一个 const 指针，一旦被初始化为指向某个地址，就不能再改变它所指向的地址。

通过使用 const 修饰指针，我们可以确保数据的完整性和指针的稳定性，避免不必要的修改和错误。这种特性在编写安全、可靠的代码时非常有用。

五、指针运算

5.1 指针±整数

指针支持与整数进行加法和减法运算。这就像你在图书馆的书架前，想要找到某本书的位置。假设你站在书架的起点（指针初始位置），然后向前走几步（加整数）或者向后退几步（减整数），就能到达目标书籍的位置。

int arr[5] = {1, 2, 3, 4, 5};
int *p = arr; // p指向数组的第一个元素// 指针加法
p = p + 2; // p现在指向数组的第三个元素
printf("%d", *p); // 输出3// 指针减法
p = p - 1; // p现在指向数组的第二个元素
printf("%d", *p); // 输出2

在这个例子中，p 是一个指向 int 类型的指针。通过指针与整数的加法和减法运算，我们可以灵活地在数组中移动指针，访问不同的元素。

5.2 指针-指针

两个指针相减可以得到它们之间的元素个数。这就像你在一条街道上，想知道两个房子之间相隔多少户。通过计算两个房子的门牌号之差，再除以每户的平均间距，就能得到它们之间的户数。

int arr[5] = {1, 2, 3, 4, 5};
int *p1 = arr; // p1指向数组的第一个元素
int *p2 = arr + 4; // p2指向数组的第五个元素int distance = p2 - p1; // 计算两个指针之间的元素个数
printf("%d", distance); // 输出4

在这个例子中，p2 - p1 计算了两个指针之间的元素个数，结果是4，表示从 p1 到 p2 之间有4个元素。

5.3 指针的关系运算

指针支持关系运算，如大于（>）、小于（<）、大于等于（>=）、小于等于（<=）等。这些运算用于比较两个指针所指向的内存地址的大小。这就像你在比较两个建筑物的高度，看哪个更高，哪个更矮。

int arr[5] = {1, 2, 3, 4, 5};
int *p1 = arr; // p1指向数组的第一个元素
int *p2 = arr + 2; // p2指向数组的第三个元素if (p2 > p1) {printf("p2指向的地址比p1大");
} else {printf("p1指向的地址比p2大");
}

在这个例子中，p2 > p1 判断 p2 是否指向的内存地址比 p1 大。由于 p2 指向数组的第三个元素，而 p1 指向第一个元素，所以条件成立，输出 “p2指向的地址比p1大”。

通过指针运算，我们可以灵活地操作内存中的数据，实现数组遍历、内存块操作等功能。指针与整数的运算、指针之间的减法以及指针的关系运算，都是C语言中非常实用的特性，能够帮助我们编写高效、灵活的代码。

六、野指针

6.1 野指针的成因

野指针是指指向不确定内存地址的指针。野指针可能是未初始化的指针，或者是已经释放了内存但仍然指向该内存地址的指针。这就像你拿到了一张没有明确地址的快递单，或者快递员已经送完快递但你还在等待。

int *p; // 未初始化的指针，是一个野指针
printf("%d", *p); // 错误：访问野指针可能导致程序崩溃

在这个例子中，p 是一个未初始化的指针，它指向的内存地址是随机的，访问这样的指针可能会导致程序崩溃或出现不可预测的行为。

6.2 如何规避野指针

6.2.1 指针初始化

在声明指针时，最好对其进行初始化，使其指向一个有效的内存地址或 NULL。这就像在拿到快递单时，先确认收货地址是否正确，或者先将快递单标记为“待发货”。

int num = 10;
int *p = # // 初始化指针，使其指向有效的内存地址

或者

int *p = NULL; // 初始化指针为NULL，表示它目前不指向任何有效的内存地址

6.2.2 小心指针越界

指针越界是指指针超出了其合法的内存范围。这就像你在图书馆找书时，超出了书架的范围，可能会撞到墙壁或其他书架。

int arr[5] = {1, 2, 3, 4, 5};
int *p = arr; // p指向数组的第一个元素p = p + 5; // 错误：指针越界，数组只有5个元素，索引从0到4
printf("%d", *p); // 错误：访问越界的指针

在这个例子中，p + 5 超出了数组的范围，访问这样的指针是不安全的。

6.2.3 指针变量不再使用时，及时置NULL，指针使用之前检查有效性

当指针变量不再使用时，将其置为 NULL，以避免悬挂指针（dangling pointer）。在使用指针之前，检查它是否为 NULL 或指向有效的内存地址。这就像在快递送达后，将快递单标记为“已收货”，避免再次使用无效的快递单。

int num = 10;
int *p = # // p指向num的地址// 在某个操作后，num不再需要被访问
p = NULL; // 将指针置为NULLif (p != NULL) {printf("%d", *p); // 安全地使用指针
} else {printf("指针无效");
}

6.2.4 避免返回局部变量的地址

函数中的局部变量在函数返回后会被销毁，因此不要返回局部变量的地址。这就像快递员送完快递后离开，但收件人还在等待，导致无法取到快递。

int* get_pointer() {int num = 10;int *p = #return p; // 错误：返回局部变量的地址，num的生命周期已经结束
}int main() {int *p = get_pointer();printf("%d", *p); // 错误：p是一个野指针，因为num的生命周期已经结束return 0;
}

在这个例子中，get_pointer 函数返回了一个局部变量的地址，当函数返回后，局部变量的生命周期已经结束，p 成为了一个野指针。正确的做法是使用动态分配的内存或静态变量。

通过以上方法，我们可以有效规避野指针的出现，确保程序的稳定性和安全性。野指针是C语言中常见的错误来源，但通过良好的编程习惯和细心的操作，我们可以避免这些问题，编写出高效、可靠的代码。

七、assert断言

assert 是一个宏，用于在调试阶段检查程序的状态是否符合预期。如果断言的条件为假，程序将终止并输出错误信息。

#include <assert.h>int *get_pointer() {int num = 10;int *p = &num;return p; // 返回局部变量的地址，返回后num的生命周期已经结束
}int main() {int *p = get_pointer();assert(p != NULL); // 检查p是否为NULL指针printf("%d", *p); // 错误：p是一个野指针，因为num的生命周期已经结束return 0;
}

在这个例子中，get_pointer 函数返回了一个局部变量的地址，当函数返回后，局部变量的生命周期已经结束，p 成为了一个野指针。使用 assert 检查 p 是否为 NULL 指针，但实际上 p 并不是 NULL，而是指向了一个无效的内存地址，因此程序可能会崩溃。

八、指针的使用和传址调用

8.1 strlen的模拟实现

strlen 是C标准库中的一个函数，用于计算字符串的长度。通过指针，我们可以模拟实现 strlen 的功能。这就像你想要知道一本书有多少页，你需要从第一页开始，一页一页地数，直到看到最后一页的页码。

#include <stdio.h>// 模拟实现strlen函数
int my_strlen(const char *str) {int length = 0;while (*str != '\0') { // 遍历字符串，直到遇到空字符'\0'length++;str++;}return length;
}int main() {const char *str = "Hello, World!";printf("字符串长度是：%d", my_strlen(str)); // 输出13return 0;
}

在这个例子中，我们通过指针 str 遍历字符串，逐个检查每个字符，直到遇到空字符 \0 为止。每检查一个字符，长度计数器 length 就增加1。最终返回字符串的长度。

8.2 传址调用和传值调用

在函数调用中，C语言支持两种参数传递方式：传值调用和传址调用。传值调用是将实际参数的值传递给形式参数，函数内部对形式参数的修改不会影响实际参数。传址调用是将实际参数的地址传递给形式参数，函数内部通过指针可以修改实际参数的值。

8.2.1 传值调用

传值调用就像你给朋友写信，你把信的内容抄写一份寄给他。他在回信中修改了信的内容，但你的原始信件内容不会改变。

#include <stdio.h>void swap(int a, int b) {int temp = a;a = b;b = temp;
}int main() {int x = 10, y = 20;swap(x, y);printf("x = %d, y = %d", x, y); // 输出x = 10, y = 20return 0;
}

在这个例子中，swap 函数的参数 a 和 b 是通过传值调用传递的。函数内部对 a 和 b 的修改不会影响主函数中的 x 和 y。

8.2.2 传址调用

传址调用就像你把一份重要文件的地址告诉给朋友，他可以直接到那个地址去修改文件内容。这样，文件的原始内容就会被改变。

#include <stdio.h>void swap(int *a, int *b) {int temp = *a;*a = *b;*b = temp;
}int main() {int x = 10, y = 20;swap(&x, &y); // 传址调用printf("x = %d, y = %d", x, y); // 输出x = 20, y = 10return 0;
}

在这个例子中，swap 函数的参数 a 和 b 是通过传址调用传递的。函数内部通过指针修改了 x 和 y 的值，因此主函数中的 x 和 y 的值发生了变化。

通过指针的使用和传址调用，我们可以实现函数对变量的直接修改，这在很多场景下非常有用，比如交换变量值、修改结构体内容等。传址调用提高了函数的灵活性和效率，避免了大量数据拷贝带来的性能损失。

总结

指针是C语言中一个强大而灵活的概念，它允许程序员直接操作内存，实现高效的数据处理和灵活的程序控制。然而，指针也是C语言中较为复杂和容易出错的部分。通过深入理解内存和地址、指针变量、指针类型、指针运算、野指针以及指针在函数传址调用中的应用等内容，我们可以更好地掌握指针的使用方法，避免常见的错误和陷阱，编写出高效、可靠的C语言程序。