指针概览 ¶

你可能已经听说过，C 语言是贴近底层的编程语言。这是因为，C 语言未对计算机硬件作过多抽象，它方便而又灵活的语言特性为与硬件交互提供了极大便利。

指针是 C 语言的核心特性之一，它的灵活性与强大性，使得 C 语言成为与硬件交互的首选语言。但是，指针也是 C 语言中最容易引发错误的特性之一，它要求使用者正确理解内存模型，并对指针的使用严加约束。

本文将尽量全面地讲解指针的定义与特性，并梳理部分使用技巧。在此之前，为了准确理解指针，我们需要先了解 C 语言的内存模型与对象模型。

底层概念 ¶

内存模型 ¶

在 C 语言的内存模型中，字节（Byte）定义为一系列连续的位（bit），是内存的最小可寻址单元。在几乎所有现代计算机上，一个字节的长度都是 8 位，我们的讨论也基于这一标准。

所谓“可寻址”指的是内存中的所有字节都拥有一个唯一编号，也即内存地址。习惯上，内存地址由长度一定的、从 0 开始递增的无符号整数表示，其长度由操作系统决定。

对象 ¶

C 语言将程序使用的数据抽象为对象，它被定义为执行环境中内存的一个区域，其内容可以表示特定类型的值。根据数据类型与长度的不同，一个对象可占据一个或多个字节，我们称起始字节的内存地址为该对象的内存地址。

每个对象可以用 memcpy 复制到 unsigned char[n] 类型的对象中，我们称生成的数组内容为对象表示。方便起见，我们通常以十六进制整数序列形式展示对象表示，每两位十六进制数代表一个字节。举例来说，int 类型常量 1 在小端序计算机上的对象表示为 0x01 00 00 00。

另外，对象表示和值并不要求一一对应，两个值相等的对象可以拥有不同的对象表示。

除了直接使用字面量（常量的一种）创建对象外，还可以通过声明语句创建，并为其分配一个标识符，以掩盖分配内存空间与访问内存地址的细节过程，并增强程序可读性。

因此，声明一个变量实际上包括两步：首先，为对象申请一块对应大小的内存空间；其次，将标识符与对象相关联。

当程序尝试读取或修改对象的内容时，我们称程序访问了该对象或该内存地址。

基本语法 ¶

指针类型 ¶

一般而言，提到“指针”时，我们实际讨论的是指针类型对象。

C 标准对指针类型的定义如下：

A pointer type may be derived from a function type, an object type, or an incomplete type, called the referenced type. A pointer type describes an object whose value provides a reference to an entity of the referenced type. A pointer type derived from the referenced type \(T\) is sometimes called "pointer to \(T\)".

C 语言中，指针类型与其他类型拥有相同的对象模型，指针类型的对象同样需要申请内存空间以存储值。不同之处在于，指针类型对象的值为“另一个对象的引用”，也即其内存地址。我们称指针类型的对象指向被引用对象。

指针类型是一种派生类型，这意味着完整的指针类型包括被引用对象的类型。由于在内存中所有数据均以一系列连续位的形式存储，为正确读取数据，这种额外的记录显然是必要的。

相对应地，不同指针类型间是否兼容，取决于被引用对象的类型是否兼容。

声明 ¶

指针类型对象的声明语法如下：

type-specifier * qualifiers declarator

其中，type-specifier 为被引用对象的类型，qualifiers 为对指针类型对象的限定，declarator为指针类型对象的标识符（名称）。

需要注意的是，声明中 * 只对直接结合的标识符生效。举例来说，如果通过语句 int * a, b; 声明变量 a 与 b，那么只有 a 会被认定为指针类型。

在声明指向某些类型对象的指针时，可通过括号使 * 优先与标识符结合，以避免运算符优先级差异导致的歧义。举例来说，语句 int *arr[3]; 声明了一个元素类型为 int * 且长度为 3 的数组 arr；语句 int (*ptr)[3]; 则声明了一个指针 ptr，它指向一个元素类型为 int 且长度为 3 的数组。

此外，被引用对象的类型可以是不完整类型。举例来说，语句 int (*p)[]; 表明指针 p 指向一个元素类型为 int，且长度未知的数组。这意味着我们不关心数组长度，或者数组长度需要在之后的程序中通过某些方法确定。相对应地，无法对解引用 p 的结果使用 sizeof 运算符。

值与运算 ¶

通过指针获得被引用对象的过程称为解引用，由运算符 * 完成；通过某个对象获得指向该对象指针的过程称为取址，由运算符 & 完成。

结合赋值操作，可根据需要通过指针访问并修改指向的对象，或令指针指向不同的对象。举例来说，对于 int 类型变量 a，语句 p = &a; 将使指针 p 的值设为 a 的内存地址，也即令 p 指向 a；在此基础上，语句 *p = 1; 将改变 p 指向的对象，也即变量 a 的值。

不过，在编写表达式时，需要注意运算符优先级的影响。举例来说，表达式 *p++ 将使指针 p 的值自增 1，而表达式 (*p)++ 将使指针 p 指向对象的值自增 1。

每种类型的指针都含有一个该类型的特殊值，称为空指针值。值为空的指针不指向任何对象，且解引用空指针是未定义行为。可使用空指针符号常量 NULL 为指针赋空值，它在 stdio.h、stdlib.h、string.h、stddef.h 等常用库中均有定义。根据 C 语言标准，NULL 的值为 0。

两个类型兼容的指针间的赋值运算、比较运算与减法运算是有效的。若指针类型不兼容，则需要进行强制类型转换。这种运算仅在少数情形下有意义，如两个指针位于同一数组内时。

指针与整数间的加法或减法运算也是有效的，其含义是令指针前移或后移若干个指向对象的长度。举例来说，表达式 p + n 的值，代表指针 p 当前指向的对象之后第 n 个对象的地址。这种运算在数组与字符串操作中十分常见。

虽然内存地址往往是一个非负整数，但是指针与整数之间不能相互转换，0 是唯一的例外：常量 0 可以赋值给指针，指针也可与常量 0 进行比较。显然，此时常量 0 将被视为空指针 NULL。

除以上运算外，其他形式的指针运算都是非法的。

用法概述 ¶

参数传递 ¶

在 C 语言中，调用函数时以值传递形式传递参数；具体而言，每次调用函数时会重新创建形参，并将实参的值复制到对应的形参。函数可以修改自身形参，但是实参的值不会随之改变。这种设计将函数与数据隔离，避免产生意料之外的副作用。

不过，如果我们期望函数产生副作用，值传递的方式便无法满足需求。为解决这一问题，我们可以引入指针类型的参数，以达到修改其他对象的目的。

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

int a = 1, b = 2;
fake_swap(a, b);

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

int a = 1, b = 2;
swap(&a, &b);

C 语言中的函数只有一个返回值。若要返回多个值，可将所有返回值放入结构体中；但是，这需要额外声明一个临时使用的结构体类型，拆解结构体的过程也耗时耗力。一个更好的方案是，向函数传递指针参数，由函数通过指针将结果写入目标对象。我们经常使用的 scanf 函数便是一个典型例子。

操作数组 ¶

一般而言，提到“数组”时，我们讨论的既可以是数组类型，也可以是数组类型的对象。

指针与数组的关系十分密切，它们之间的转换也是 C 语言中最常见的类型转换之一。一般来说，用指针编写的程序比用数组编写的程序执行速度快，但可读性相对较差。

数组退化 ¶

数组的值就是该数组第一个元素的地址；实际使用中，数组也经常可被看作指向其首元素指针。事实上，C 标准对此作如下规定：

任何数组类型的左值表达式，当用于异于

• 作为取地址运算符的操作数
• 作为 sizeof 的操作数
• 作为用于数组初始化的字符串字面量

的语境时，会经历到指向其首元素的指针的隐式转换。

习惯上，我们将数组到指针的隐式转换过程，称为数组退化为指针。

C 标准规定，表达式 E1[E2] 等价于 (*((E1) + (E2)))。这意味着，数组元素在内存中连续。另外，如果确信相应元素存在，可以通过指定超出数组范围的下标，访问数组前后的元素。

由于复制数组的开销经常大到不可接受，C 标准规定，作为参数传递时数组也应被隐式转换为其首元素指针。所以，在语法层面上，函数声明与定义中，形如 char str[] 的形参声明与 char *str 是等价的，不过前者可以提醒函数编写者与使用者留意 str 的实际含义。当然，你也可以传入指向其他元素的指针，这在传参过程中没有区别。

需要注意的是，返回类型中的数组不会自动转换成指针，因此形如 char func() []; 的函数声明是非法的。

int a[3], *p;
printf("%zu %zu", sizeof(a), sizeof(p));

多维数组 ¶

与指针类似，数组也是派生类型。不同之处在于，为了正确访问数组元素，需要知道数组元素的长度，即数组元素的类型必须是完整的。

我们称元素类型为数组的数组为多维数组。需要注意的是，[] 运算符是从右往左结合的。举例来说，语句 int a[2][3]; 声明了一个长度为 2的数组 a，它的元素类型为 int [3]；对应地，通过表达式 a[x][y] 访问数组元素时，x 与 y 的取值范围分别为 0~1 与 0~2。

当应用数组到指针转换时，多维数组被转换成指向其首元素的指针。我们称这种指向数组的指针为数组指针。举例来说，int [2][3] 类型的二维数组会被转换为 int (*)[3] 类型的数组指针。

我们称元素类型为指针的数组为指针数组。容易想到，指针数组其实是个一维数组；不过由于其元素类型为指针，访问元素的形式与多维数组有部分相似之处。指针数组的一个典型用法是存储并传递命令行参数，即一种 main 函数声明 int main(int argc, char *argv[]) 中的 argv 参数。

类似地，我们称指向某个指针的指针为多级指针。二级指针常见于链表操作中，更高级的指针则很少出现。

字符串 ¶

我们知道，C 语言中的字符串实际上是一个空字符（称为中止字符）结尾的字符数组。因此，上一小节的讨论同样适用于这一小节。

由于字符串同时具有数组的属性，讨论与内存空间有关的概念与操作时，为避免混淆，我们将数组对象占用的字节数称为其大小，将实际组成字符串的字符数称为其长度。一个直观理解是，字符串的大小计入中止字符，而其长度不计入。

在 C 语言中，我们可以使用字符串字面量表示一个字符串。字符串字面量是由一对 " 包围的任意长度的字符序列，其中的字符可以是一般字符或转义字符，如 "abc"、"x y\nz"、""。字符串字面量的末尾隐式包含中止字符。举例来说，"" 代表大小为 1 的字符数组，它的唯一元素为 '\0'。

字符串字面量的类型为 char [N]，其中 N 是字符串的大小，包括隐式的中止字符。显然，字符串字面量也遵守数组到指针的隐式转换规则。

char *str = "abc";
printf("%zu %zu\n", sizeof("abc"), sizeof(str));

不难想到，我们可以使用字符串字面量初始化数组，其效果相当于使用对应的字符数组常量初始化。与一般的数组初始化类似，数组长度可由初始化器隐式指定。举例来说，语句 char str[] = "abc"; 等价于语句 char str[] = {'a', 'b', 'c', '\0'};，它声明并初始化了一个长度为 4 的字符数组 str。

数组的大小可以比字符串字面量的大小少 1，此时中止字符将被忽略。举例来说，语句 char str[3] = "abc"; 等价于语句 char str[3] = {'a', 'b', 'c'};。

char str[3] = "abc";
char backdoor[] = "xyz";
printf("%s", str);

根据隐式转换规则，在多数表达式中，字符串字面量将会隐式转换为指向它的指针。也就是说，该指针的值是字符串字面量的内存地址。类似地，被用于对指针的初始化时，字符串字面量也会退化为指针。

在函数内修改字符串时，传入的字符数组将会退化为指针，数组的大小信息因此丢失。可以想到，字符串末尾的空字符正是为这种情形设计的。

C 语言标准库中提供了一系列字符串操作函数，它们大多被定义在 string.h 头文件中，使用时均需保证提供的字符串格式符合约定。

函数指针 ¶

有时，我们希望函数可以遵循指定的规则，或者完成指定操作，但是又不希望或无法实现一系列高度相似的函数，因此我们希望在参数中引入另一个函数。C 语言为此提供了指向函数的指针，称为函数指针。

在编译得到的可执行文件中，程序中的指令与数据被分别存储，以供 CPU 访问并使用。函数指针的值，实际上是函数第一条指令的地址，也即函数的入口地址。

与数组类似，函数也会退化为指针。C 标准对此作如下规定：

任何函数指代器表达式，在用于异于下列语境时

• 作为取址运算符的操作数
• 作为 sizeof 的操作数

会经历到指向表达式所指代函数的指针的转换。

利用这个规则，我们可以使用函数名为函数指针赋值，也可以写出复杂的表达式。需要注意的是，() 运算符也是从右往左结合的，且优先级高于 * 运算符。举例而言，语句 int *f(void); 声明了一个函数 f，它的返回值类型为 int *；而语句 int (*fp)(void); 声明了一个函数指针 fp，它指向一个返回值类型为 int 的函数。

结构体与内存管理 ¶

结构体是一种聚合类型，它将多个不同类型的对象组合成一个对象。结构体经常被用于给一个复杂概念建立模型。

在复杂数据结构中，线性的数组往往无法展示数据间的逻辑关系，因此，我们往往会大量使用结构体与结构体指针。由于通过结构体指针访问其成员的情形十分常见，C 语言提供了 -> 运算符以简化表达式。举例来说，表达式 p->x 等价于 (*p).x。

由于建立过程比较繁琐，我们希望一直存储完成建立的数据结构，以供程序中的其他部分使用；另一方面，它们往往会占用比较多的内存空间，因此我们也希望在需要时立刻销毁。对于这些需求，无论是全局变量还是静态局部变量都仍然不够灵活。为此，C 语言在 stdlib.h 中提供了动态内存管理函数。

常用的动态内存管理函数包括 malloc 与 free，它们分别负责申请与释放内存空间。

进阶技巧 ¶

printf("%d", a[0]);
for (int i = 1; i < n; i++)
{
    printf(" %d", a[i]);
}

for (int i = 0; i < n; i++)
{
    printf((!i) ? "%d" : " %d", a[i]);
}

for (int i = 0; i < n; i++)
{
    printf(" %d" + !i, a[i]);
}

int a = 1;
for (int i = 0; i < 32; i++)
    printf("%d", (a >> (31 - i)) & 1);

double a = 1.0;
unsigned long long p = *(unsigned long long *)&a;
for (int i = 0; i < 64; i++)
    printf("%llu", (p >> (63 - i)) & 1);

typedef struct node
{
    int val;
    struct node *next;
} Node;

Node *remove(Node *head, int val)
{
    for (Node *prev = NULL, *curr = head; curr; )
    {
        Node *next = curr->next;
        if (curr->val == val)
        {
            if (prev)
                prev->next = next;
            else
                head = next;
            free(curr);
        }
        else
            prev = curr;
        curr = next;
    }
    return head;
}

void remove(Node *head, int val)
{
    for (Node **curr = &head; *curr; )
    {
        Node *entry = *curr;
        if (entry->val == val)
        {
            *curr = entry->next;
            free(entry);
        }
        else
            curr = &entry->next;
    }
}