C语言指针从入门到基础详解（非常详细）

指针是C语言中最具表现力也最容易引发问题的特性之一。掌握指针的底层原理、使用规范与常见陷阱，是成为系统级程序员的关键基础。

指针是C语言中最具表现力也最容易引发问题的特性之一。掌握指针的底层原理、使用规范与常见陷阱，是成为系统级程序员的关键基础。从内存地址到指针运算，从野指针到断言，我们将深入解析C语言中指针的每一个细节。

内存和地址

C语言中的指针本质上是内存地址的引用。内存被划分为一个个字节大小的单元，每个单元都有一个唯一的地址编号。CPU通过这些地址来读取和写入数据。在C语言中，这个地址被称为指针。

地址是内存单元的编号，它决定了CPU如何访问数据。例如，当我们声明一个整型变量 int a = 10;，系统就会在内存中为 a 分配四个字节的空间。通过取地址操作符 &，我们能够获取 a 的地址。

int a = 10;
printf("%p\n", &a);

这段代码会打印 a 的内存地址。C语言中，指针变量用于保存这些地址，并能通过解引用操作符 * 来访问地址中存储的数据。

指针变量和地址

指针变量是一种特殊的变量，它用于存储地址。例如：

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

在这一段代码中，pa 是一个指针变量，它保存了 a 的地址。C语言中，指针变量的类型决定了它指向的数据类型。如 int* pa 表示 pa 指向一个 int 类型的数据对象。

解引用操作符 * 的作用是通过指针访问其指向的值。例如：

int a = 10;
int* pa = &a;
printf("%d", *pa);

这段代码会打印 a 的值。通过 *pa，系统会解析 pa 指向的地址，并读取其内容。

指针变量的大小

在32位系统中，一个指针变量的大小是4个字节。这是因为32位机器有32根地址总线，每根地址线只能输出0或1，构成一个32位的地址。因此，指针变量的大小是4个字节。

同样地，在64位系统中，一个指针变量的大小是8个字节。这说明指针变量的大小与类型无关，只与平台的字长有关。无论是指向 int、char 还是 double 的指针，其大小在相同的平台下是相同的。

指针变量类型的意义

指针变量的类型决定了它在解引用时可以访问多少字节的数据。例如，int* 类型的指针在解引用时可以访问4个字节，而 char* 类型的指针只能访问1个字节。

理解这一点可以通过下面的代码示例：

int n = 0x11223344;
int* pi = &n;
char* pc = (char*)&n;

*pi = 0;   // 修改整个int对象
*pc = 0;   // 只修改第一个字节

第一段代码将 n 的整个值设为0，而第二段代码只修改了第一个字节。这是由于 int* 指针在解引用时可以访问4个字节，而 char* 只能访问1个字节。

指针的类型还决定了它在进行指针运算时的步长。例如，char* 类型的指针在加1时步长是1个字节，而 int* 类型的指针加1时步长是4个字节。

void* 指针

在C语言中，void* 是一种特殊的指针类型，它不指向任何特定的数据类型。这种指针可以接受任何类型的数据地址，常用于需要泛型处理的场景。例如，在函数参数中使用 void* 可以接收不同指针类型的数据。

然而，void* 指针不能直接进行解引用或指针运算。因此，使用 void* 指针时，必须先将其转换为具体的指针类型：

void* p = malloc(100);
char* pc = (char*)p;

在函数参数中使用 void* 指针可以实现泛型编程，使得一个函数能够处理多种类型的数据，提升代码复用性。

const 修饰指针

const 是C语言中用于防止修改的重要关键字。它可以修饰变量或指针变量，防止意外修改数据。

当 const 修饰变量时，变量的值不能被修改：

const int n = 0;
n = 20;  // 编译错误

然而，如果通过指针绕过 const 修饰的变量，仍然可以修改其值：

const int n = 0;
int* p = &n;
*p = 20;  // 通过指针修改

为了避免这种情况，应该让指针本身也被 const 修饰。例如：

const int* p = &n;
*p = 20;  // 编译错误，不能通过指针修改

const 修饰指针变量时，它的位置决定了其修饰对象。如果 const 放在 * 的左边，修饰的是指针指向的内容；如果放在 * 的右边，修饰的是指针变量本身。例如：

int* const p = &n;  // p不能被修改
const int* p = &n;  // p指向的内容不能被修改

指针运算

指针 + 整数

指针运算是一种非常常见的操作，它决定了指针如何“移动”。例如：

int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int* p = &arr[0];
int sz = sizeof(arr)/sizeof(arr[0]);

for(int i=0; i<sz; i++) {
    printf("%d ", *(p+i));
}

这段代码会打印数组 arr 中的每个元素。p+i 表示指针移动了 i 个元素的位置。

指针 - 指针

两个指针相减的结果是它们之间的元素个数。这个特性可用于实现一些基础库函数，如 strlen。

size_t my_strlen(char* s) {
    char* tmp = s;
    while(*(++s))
        ;
    return s - tmp;
}

这段代码通过指针运算模拟实现了 strlen，计算了字符串的长度。这种技巧在系统编程和底层开发中非常常见。

指针关系计算

指针之间的比较可以用于判断指针是否在某个内存范围内。例如：

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 < arr + sz) {
    printf("%d ", *p);
    p++;
}

这段代码会循环打印数组 arr 中的每个元素，直到指针超出数组范围。

野指针

野指针成因

野指针是未初始化或指向已释放内存的指针，它的值是随机的，使用野指针可能导致不可预知的错误。

未初始化的指针

int* p;
*p = 20;  // 未初始化的指针，可能导致崩溃

指针越界访问

int arr[10] = {0};
int* p = &arr[0];

for(int i=0; i<=11; i++) {
    *(p++) = i;  // 越界访问会导致野指针
}

指针指向的空间释放

int* test() {
    int n = 100;
    return &n;  // 返回局部变量地址，该地址在函数结束后不再有效
}

int main() {
    int* p = test();
    printf("%d\n", *p);  // 该指针不再指向有效内存
    return 0;
}

这些场景都是野指针的典型成因。

如何避免野指针

1. 指针初始化：在声明指针后，立即为其赋值有效的地址，或者赋值 NULL。

c int num = 10; int* p1 = # int* p2 = NULL;

1. 小心指针越界访问：在使用指针前，确保它指向的内存空间是合法的。使用前检查其有效性。

2. 避免返回局部变量的地址：局部变量在函数结束后会被销毁，其地址无法再使用。

assert 断言

assert 是一个非常有用的调试工具，用于在运行时检查条件是否成立。如果条件为假，assert 会立即终止程序。

#include <assert.h>
int main() {
    int i = 0;
    assert(i != 0);  // 如果i为0，程序会终止
}

使用 assert 时，必须包含 <assert.h> 头文件。在发布版本中，可以通过定义 NDEBUG 宏来禁用断言：

#define NDEBUG
#include <assert.h>

断言在代码调试中非常常见。例如，我们可以用它来检查指针是否为空：

int* p = test();
assert(p != NULL);  // 如果p为空，程序会终止

传值调用与传址调用

传值调用和传址调用是C语言中处理函数参数的两种方式。理解它们的区别是掌握指针用途的关键。

传值调用

在传值调用中，函数的参数是实参的副本。函数内部对参数的修改不会影响实参本身。例如：

void Swap1(int x, int y) {
    int tmp = x;
    x = y;
    y = tmp;
}

int main() {
    int a = 0;
    int b = 0;
    Swap1(a, b);
    printf("a=%d, b=%d\n", a, b);  // a和b未交换
}

传址调用

在传址调用中，函数参数是内存地址。函数内部可以修改该地址中存储的值，从而影响主调函数中的变量。例如：

void Swap2(int* px, int* py) {
    int tmp = *px;
    *px = *py;
    *py = tmp;
}

int main() {
    int a = 0;
    int b = 0;
    Swap2(&a, &b);
    printf("a=%d, b=%d\n", a, b);  // a和b交换
}

传址调用是修改主调函数变量值的唯一方式。如果函数内部只需要使用主调函数的变量值，可以采用传值调用；如果需要修改变量值，则必须使用传址调用。

指针在系统编程中的应用

指针是系统编程的核心工具之一。它允许我们直接操作内存，这是实现高性能编程和低层操作的关键。

在系统编程中，指针常用于：

• 内存管理：如 malloc、free 等函数的使用。
• 数据结构：如链表、树、图等结构的实现。
• 函数参数传递：如实现传址调用，进行变量修改。
• 字符串操作：如 strcpy、strcat、strlen 等字符串函数的模拟实现。

掌握指针的用法，是写高质量C语言代码的前提。

指针的常见错误与最佳实践

常见错误

1. 未初始化的指针：使用未初始化的指针可能导致无法预测的行为。
2. 野指针：指向已释放内存或越界访问的指针是野指针，会引发严重错误。
3. void* 指针的误用：void* 指针不能直接解引用或进行算术运算，必须先转换为具体类型。
4. const 修饰不当：const 修饰位置错误，可能导致数据被意外修改。

最佳实践

• 初始化指针：在声明指针后立即赋值，或者赋值为 NULL。
• 使用 assert 检查指针有效性：在使用指针前，确保其指向内存是有效的。
• 避免返回局部变量的地址：局部变量在函数结束后会被销毁。
• 合理使用 const：在需要防止修改数据时，使用 const 修饰变量或指针。

C语言指针的未来发展

随着系统编程和嵌入式开发的不断深入，C语言指针仍然是不可替代的核心工具。尽管现代语言如C++、Rust提供了更安全的指针管理机制，但C语言的灵活性仍然使其在底层开发中具有优势。

在未来的系统开发中，指针的使用将更加注重安全性和可维护性。合理使用 const、避免野指针、正确使用指针运算，是编写高质量C语言代码的基础。

关键字列表

C语言, 指针, 内存地址, 取地址操作符, 解引用操作符, 指针变量, const, 野指针, assert, 传值调用, 传址调用