当前位置： 首页 > news >正文

C程序中的指针：动态内存、链表与函数指针

news 2025/10/20 8:10:40

C程序中的指针：动态内存、链表与函数指针

指针是 C 语言的灵魂，是其强大功能与极致灵活性的核心体现。一位真正精通 C 语言的程序员，不仅要掌握指针的基本概念，更需能娴熟地运用高级指针技术来驾驭复杂的数据结构和算法。本文将剖析 C 语言中与指针相关的几个核心高级主题，包括动态存储分配的原理与实践、链式数据结构（以链表为核心）的构建与操作，以及函数指针的强大应用，同时也会探讨 C99 标准为指针带来的现代特性。

动态存储分配：内存的按需使用与生命周期管理

在 C 语言编程中，常规数组等数据结构的大小在程序编译时就已固定。这带来了一个显著的挑战：我们必须在编码阶段预测程序运行时所需的最大空间。若预估过小，程序将无法处理超出预期的数据量；若预估过大，则会造成宝贵的内存资源被长期闲置和浪费。幸运的是，C 语言提供了动态存储分配机制，允许程序在执行期间根据实际需求向操作系统申请内存单元。这一能力是构建可伸缩、高效数据结构（如可变长字符串、动态数组及复杂结构体）的基石。

内存分配函数：malloc、calloc 与 realloc

标准库 <stdlib.h> 提供了三个核心的内存分配函数，它们是动态内存管理的“三驾马车”。

  • malloc: “memory allocation”的缩写。它负责分配一块指定大小（以字节为单位）的内存，但不对这块内存进行任何初始化。其内容是未知的、随机的。由于省去了清零的开销，malloc 是三者中最高效、最常用的一个。
  • calloc: “contiguous allocation”的缩写。它不仅分配内存，还会将所分配内存块的每一个字节都初始化为零。这在创建数组并希望其元素初始值为 0 时特别有用。
  • realloc: “re-allocation”的缩写。它用于调整一个先前已分配内存块的大小，可以将其扩大或缩小。扩大时，新增部分的内容是未初始化的。

这些函数成功时返回一个 void * 类型的“通用指针”。这是一种特殊的指针类型，它不指向任何具体的数据类型，本质上只是一个纯粹的内存地址。它的通用性体现在可以被直接赋值给任何类型的指针变量，而无需显式类型转换。

一个极其重要的、关乎程序鲁棒性的编程实践是，必须严格检查内存分配函数的返回值。当系统资源紧张，无法满足内存请求时，这些函数会返回一个空指针（null pointer），在代码中用宏 NULL 表示。试图通过一个空指针去读写内存是严重的错误，会导致未定义的行为，通常的后果就是程序立即崩溃。因此，安全可靠的代码总是包含如下的检查逻辑：

p = malloc(10000);
if (p == NULL) {/* 内存分配失败；必须采取适当的错误处理措施，例如打印错误信息并终止程序。*/
}

一些程序员倾向于将分配与检查合并为一行，这是一种更为紧凑的写法：

if ((p = malloc(10000)) == NULL) {/* 分配失败，采取行动 */
}
动态分配字符串与数组

动态内存对于处理长度在运行时才能确定的字符串尤其关键。为字符串分配内存时，一个绝对不能忘记的细节是为字符串末尾的空字符 \0 预留一个字节的空间。

char *p;
int n = strlen(some_other_string); // 假设字符串长度为n
// 需要分配 n 个字符的空间，外加 1 个给空字符
p = malloc(n + 1); 
if (p == NULL) { /* 错误处理 */ }
strcpy(p, some_other_string);

动态分配也使得编写能够返回“新”字符串的函数成为可能。例如，下面的 concat 函数将两个输入字符串连接起来，并将结果存储在一个全新的、动态分配的内存块中返回。此函数的调用者在使用完毕后，必须承担起释放这块内存的责任。

/** concat: 连接 s1 和 s2，返回一个指向新分配内存的指针，* 其中包含连接后的字符串。*/
char *concat(const char *s1, const char *s2)
{char *result;// 计算总长度，并为 null 终止符加 1result = malloc(strlen(s1) + strlen(s2) + 1);if (result == NULL) {printf("错误: concat 函数内 malloc 失败\n");exit(EXIT_FAILURE); // 严重错误，终止程序}// 首先复制第一个字符串，然后追加第二个strcpy(result, s1);strcat(result, s2);return result;
}

对于数组，动态分配的逻辑相似，但计算所需空间时必须使用 sizeof 运算符来确保代码的可移植性和正确性。为一个包含 n 个整数的数组分配空间，唯一正确的方式是：

int *a;
a = malloc(n * sizeof(int));

如果开发者硬编码某个具体的字节数（例如，假设 int 占用 4 字节而写成 malloc(n * 4)），那么当这段代码被移植到 int 类型占用不同大小（如 2 字节或 8 字节）的系统上时，就会导致内存分配不正确，从而引发难以追踪的程序错误。

内存的释放与风险

动态分配的内存来自一个称为堆（heap）的自由存储池。当程序通过 malloc 等函数分配了内存，但随后丢失了所有指向该内存块的指针时（例如，将指针变量重新赋值为其他地址），这块内存就变成了垃圾（garbage）。它既无法被程序访问，也无法被再次分配，从而造成了内存泄漏（memory leak）。C 语言没有内建的自动垃圾回收机制，因此，程序员必须通过调用 free 函数来显式地回收不再需要的内存，将其归还给堆。

p = malloc(...);
q = malloc(...);
// 在 p = q 赋值之前，p 原本指向的内存块将无人引用
// 因此必须先释放它
free(p); 
p = q;

然而，free 的使用也引入了一个新的、同样危险的风险：悬空指针（dangling pointer）。调用 free(p) 会释放 p 所指向的内存块，但这个操作并不会改变指针变量 p 自身的值。此时，p 仍然存储着那个已被释放、不再属于程序的内存地址。如果后续代码不慎再次通过 p 去访问或修改这块内存，将导致严重且不可预测的后果，因为这块内存可能已经被系统重新分配给程序的其他部分，甚至是其他程序。

链表：动态数据的链式艺术

动态存储分配为构建诸如链表（Linked List） 等链式数据结构提供了坚实的基础。链表由一系列结点（node） 串联而成，每个结点不仅包含业务数据，还包含一个指向链中下一个结点的指针。这种结构赋予了链表极高的灵活性：它不像数组那样有固定的大小，可以轻易地在任意位置插入和删除结点，从而实现按需增长或缩小。当然，这种灵活性是以牺牲数组的“随机访问”能力为代价的；访问链表中靠近末尾的结点需要从头开始遍历，耗时更长。

结点声明与创建

首先，我们需要用 struct 定义一个结点类型。一个典型的单向链表结点结构包含数据域和一个指向同类型结构的指针域。

struct node {int value;                 /* 存储在结点中的数据 */struct node *next;         /* 指向下一个结点的指针 */
};

需要特别注意的是，当一个结构体内部包含一个指向自身类型的指针成员时，必须使用结构标记（此处的 node），而不能仅仅依赖 typedef 来定义类型别名。这是因为在编译器解析 next 成员的类型时，struct node 作为一个标记已经被识别，即使其完整定义尚未结束。

创建一个新结点的过程通常分为三步：分配内存、存储数据、插入链表。

struct node *new_node;
// 1. 为一个新结点分配足够的内存
new_node = malloc(sizeof(struct node));
if (new_node == NULL) { /* 错误处理 */ }// 2. 将数据存入新结点
// new_node->value 是 (*new_node).value 的语法糖
new_node->value = 10;

这里使用了 -> 运算符，它是通过指针访问结构体成员的专用、便捷方式。new_node->value 完全等同于 (*new_node).value，但可读性更强，也更常用。

链表操作：插入、搜索与删除

在链表头部插入一个新结点是最简单高效的插入操作。它仅需两步：首先，让新结点的 next 指针指向链表现有的第一个结点；然后，更新链表的头指针 first，使其指向这个新插入的结点。

// 假设 first 是指向链表头部的指针
new_node->next = first;
first = new_node;

这个逻辑即使在链表为空（first 为 NULL）时也完全正确。

我们可以将这个核心逻辑封装成一个函数。下面的 Notes 函数接收当前链表的头指针和要添加的数据，然后返回一个指向新链表头部的指针。

/** add_to_list: 在链表 list 的头部插入一个包含整数 n 的新结点。* 返回指向新链表头部的指针。*/
struct node *add_to_list(struct node *list, int n)
{struct node *new_node;new_node = malloc(sizeof(struct node));if (new_node == NULL) {printf("错误: add_to_list 函数内 malloc 失败\n");exit(EXIT_FAILURE);}new_node->value = n;new_node->next = list; // 新结点的下一个是旧的链表头return new_node;       // 新结点现在是新的链表头
}// 调用方式：
// first 指针将被更新为 add_to_list 的返回值
first = add_to_list(first, 10);

搜索链表通常使用一个 for 循环来遍历所有结点，这是一种非常地道且简洁的 C 语言写法：

/** 遍历链表并打印每个结点的值*/
struct node *p;
for (p = first; p != NULL; p = p->next) {printf("%d ", p->value);
}

从链表中删除一个结点则相对复杂。关键在于，为了将待删除结点从链中断开，我们必须修改其前一个结点的 next 指针。这意味着在搜索待删除结点时，我们不能只找到它本身，还必须同时记录下它的前驱结点。解决这个问题的一个经典方法是“追踪指针”法：在遍历链表时，同时维护一个指向当前结点的指针 cur 和一个指向其前驱结点的指针 prev。

下面的 delete_from_list 函数完整地展示了这一删除逻辑。它巧妙地利用了一个 for 循环来同时移动 cur 和 prev 指针以定位目标，并特别处理了待删除结点恰好是头结点的特殊情况。

/** delete_from_list: 从链表 list 中删除第一个值为 n 的结点。* 返回指向可能已修改的链表头部的指针。*/
struct node *delete_from_list(struct node *list, int n)
{struct node *cur, *prev;// 使用追踪指针法进行搜索// cur 从 list 开始，prev 初始化为 NULL// 循环条件：cur 不为空且 cur 的值不是 n// 每次迭代：prev 跟随到 cur 的位置，cur 前进到下一个结点for (cur = list, prev = NULL;cur != NULL && cur->value != n;prev = cur, cur = cur->next); // 循环体为空，所有操作都在 for 语句的头部完成if (cur == NULL)return list;           // 未找到值为 n 的结点，链表不变if (prev == NULL)list = list->next;     // 待删除的是第一个结点，更新链表头elseprev->next = cur->next;// 待删除的是中间或尾部结点，绕过它free(cur); // 释放被删除结点的内存return list;
}

指向函数的指针：将算法作为参数传递

C 语言的指针不仅可以指向各种数据类型，还可以指向函数。函数本质上也是一段存储在内存中的代码，因此每个函数都有其入口地址。函数指针最强大的用途之一，便是作为其他函数的参数。这使得我们可以将一个具体的算法（以函数形式实现）传递给另一个更为通用的函数，实现高度的模块化和灵活性。

声明一个函数指针时，必须注意语法的细节。例如，一个指向“接收一个 double 参数并返回 double 类型结果”的函数的指针 f，其声明如下：

double (*f)(double);

这里的括号 (*f) 至关重要，它确保了 * 运算符优先与 f 结合，表明 f 是一个指针。如果没有这对括号，double *f(double) 将被编译器解释为一个名为 f、返回 double * 类型指针的函数原型声明。

qsort：通用排序算法的典范

标准库中的 qsort 函数是函数指针应用的绝佳范例。它是一个极其通用的排序函数，能够对任何类型的数组进行排序，无论数组元素是基本类型、结构体还是其他任何类型。qsort 的原型定义在 <stdlib.h> 中：

void qsort(void *base, size_t nmemb, size_t size,int (*compar)(const void *, const void *));

qsort 的工作方式依赖于这四个参数：

  • base：一个 void * 指针，指向待排序数组的第一个元素。
  • nmemb：一个 size_t 类型的值，表示数组中要排序的元素数量。
  • size：一个 size_t 类型的值，表示数组中每个元素所占用的内存大小（以字节为单位），通常通过 sizeof 获得。
  • compar：一个指向比较函数的指针。这是实现其通用性的关键。

我们必须提供一个自定义的比较函数，qsort 会在内部排序过程中需要比较两个数组元素时调用它。这个函数接收两个 const void * 类型的指针，它们分别指向要比较的两个元素。函数的返回值必须遵循以下约定：

  • 若第一个元素应排在第二个元素之前，返回一个负整数。
  • 若两个元素相等（或顺序无关），返回零。
  • 若第一个元素应排在第二个元素之后，返回一个正整数。

假设我们有一个 struct part 类型的数组，希望按照零件编号 number 进行升序排序。我们需要编写一个符合 qsort 要求的比较函数：

struct part {int number;char name[26];int on_hand;
};// 比较函数，用于按 part 结构的 number 成员进行比较
int compare_parts(const void *p, const void *q)
{// 必须将 void* 指针强制转换为具体的结构体指针类型才能访问其成员const struct part *p1 = p;const struct part *q1 = q;if (p1->number < q1->number)return -1;else if (p1->number == q1->number)return 0;elsereturn 1;
}// 调用 qsort 对 inventory 数组进行排序
qsort(inventory, num_parts, sizeof(struct part), compare_parts);

对于数值比较，如果能确保不会发生溢出，可以简化为直接返回差值：

int compare_parts_concise(const void *p, const void *q) {// 强制类型转换可以直接在表达式中使用return ((const struct part *)p)->number - ((const struct part *)q)->number;
}

注意，表达式 ((const struct part *)p) 两边的括号是必需的，因为 -> 运算符的优先级高于类型转换 (type)。

C99 中的指针新特性

C99 标准引入了一些面向高级程序员的指针特性，旨在提升代码的优化潜力和表达能力。

受限指针 (restrict)

restrict 关键字可以用于修饰指针，它向编译器提供了一个重要的、关于优化的承诺。它向编译器声明，在一个特定的作用域内，如果一个内存对象需要被修改，那么对该对象的访问将只能通过这个被 restrict 修饰的指针进行。换言之，不存在其他“别名”（alias）来访问或修改该对象。

这个特性的一个典型应用场景是标准库函数 memcpy 的原型：

void *memcpy(void *restrict s1, const void *restrict s2, size_t n);

这里的 restrict 明确告知编译器和程序员，源内存区域 s2 和目标内存区域 s1 不应该有任何重叠。基于这个承诺，编译器可以生成更高效的、不必担心数据覆盖问题的内存复制指令。与之相对的 memmove 函数则没有 restrict 关键字，因为它被设计为能够安全、正确地处理源和目标内存重叠的情况。

灵活数组成员

为了以标准化的方式解决在结构体末尾定义一个可变长度数组的需求，C99 引入了灵活数组成员（flexible array member），这是对传统非标准的“struct hack”技巧的正式支持。当一个结构的最后一个成员是数组时，其长度可以被省略。

struct vstring {int len;char chars[]; /* 灵活数组成员 - 仅限 C99及之后标准 */
};

这个 chars 成员在计算 sizeof(struct vstring) 时不占用任何空间。在为这个结构分配内存时，需要根据实际需要的数组长度，在结构体本身大小的基础上额外请求空间：

// 为一个能容纳 n 个字符的 vstring 结构分配空间
int n = 20;
struct vstring *str = malloc(sizeof(struct vstring) + n);
if (str) {str->len = n;// 现在 str->chars 可以像一个长度为 n 的数组一样使用strcpy(str->chars, "example string");
}

这种方式比定义一个固定大小的数组更节省内存，也比传统的 char chars[1] 技巧更安全、意图更明确。

附录：代码解读

inventory2.c 中的有序链表插入

在 inventory2.c 示例中，程序维护一个按零件编号排序的零件数据库链表。其 insert 函数是理解有序链表插入操作的绝佳案例。

void insert(void)
{struct part *cur, *prev, *new_node;new_node = malloc(sizeof(struct part));// ... 错误检查和数据输入 ...// 关键部分：寻找正确的插入位置for (cur = inventory, prev = NULL;cur != NULL && new_node->number > cur->number;prev = cur, cur = cur->next);// 检查零件号是否已存在if (cur != NULL && new_node->number == cur->number) {printf("零件已存在。\n");free(new_node); // 释放为新结点分配的内存return;}// 执行插入操作new_node->next = cur;if (prev == NULL)inventory = new_node; // 插入在链表头部elseprev->next = new_node; // 插入在 prev 和 cur 之间
}

代码解读：

  1. 寻找插入点：for 循环是此函数的核心。它使用 cur 和 prev 两个追踪指针遍历链表。循环的条件是 cur != NULL && new_node->number > cur->number，这意味着循环会一直进行，直到：
    • cur 变成 NULL，表示新零件的编号比链表中所有现有零件的编号都大，应插入在末尾。
    • new_node->number 不再大于 cur->number，表示已经找到了第一个编号大于或等于新零件编号的结点。这里就是正确的插入位置，新结点应该插在 prev 和 cur 之间。
  2. 重复性检查：循环结束后，if (cur != NULL && new_node->number == cur->number) 这条语句检查找到的位置上的零件编号是否与新零件的编号完全相同。如果是，则说明零件已存在，函数会释放之前为 new_node 分配的内存，并提前返回。
  3. 执行插入：
    • new_node->next = cur; 这一步将新结点的 next 指针指向 cur。无论 cur 是 NULL（插入在末尾）还是指向某个结点（插入在中间），这都是正确的。
    • if (prev == NULL) 判断是否需要插入在链表的头部。这种情况发生在循环一次都未执行时（即新零件的编号小于链表中所有零件的编号）。此时，直接更新全局的 inventory 头指针。
    • 否则 (else)，说明插入位置在链表中间或尾部，需要修改前驱结点 prev 的 next 指针，使其指向新结点，从而完成插入。
指向指针的指针：修改函数外部的指针

在 Notes 的第一个版本中，函数返回一个新的头指针，调用者必须用这个返回值去更新自己的指针变量（first = add_to_list(first, 10);）。如果我们希望函数能直接修改调用者传来的指针变量（即 first），就需要使用指向指针的指针。

问题分析：
在 C 语言中，所有函数参数都是按值传递的。当你传递一个指针 first 给函数时，函数内部得到的是 first 这个地址值的一个副本。在函数内部修改这个副本（例如 list = new_node;）丝毫不会影响函数外部原始的 first 变量。

解决方案：
为了让函数能修改 first，我们不能传递 first 的值，而应该传递 first 的地址。这样，函数参数的类型就变成了 struct node **（一个指向 struct node * 类型指针的指针）。

// 修改版的 add_to_list，直接修改调用方的头指针
void add_to_list(struct node **list, int n)
{struct node *new_node;new_node = malloc(sizeof(struct node));if (new_node == NULL) {printf("错误: malloc 失败\n");exit(EXIT_FAILURE);}new_node->value = n;// *list 解引用，得到调用方的 first 指针本身new_node->next = *list; *list = new_node;
}// 调用方式
struct node *first = NULL;
// 传递 first 变量的地址
add_to_list(&first, 10); 
add_to_list(&first, 20); 
// 调用后，first 的值已经被函数直接修改

代码解读：

  • 函数签名变为 void add_to_list(struct node **list, int n)，list 现在是一个指向指针的指针。
  • 在函数内部，list 存储的是 first 变量的内存地址。
  • *list 是对 list 的解引用操作，它访问到的就是 first 指针变量本身。
  • new_node->next = *list; 这句代码读取 first 的当前值（即旧的链表头地址），并赋给新结点的 next 成员。
  • *list = new_node; 这句代码将新结点的地址赋值给 first 变量，从而直接在函数外部修改了链表的头。
http://www.dtcms.com/a/503258.html

相关文章：

  • 免费注册网站软件2022推广app赚佣金平台
  • 【Linux运维实战】彻底修复 CVE-2011-5094 漏洞
  • Java | 基于redis实现分布式批量设置各个数据中心的服务器配置方案设计和代码实践
  • STM32中硬件I2C的时钟占空比
  • iFlutter --＞ Flutter 开发者 的 IntelliJ IDEA / Android Studio 插件
  • Easyx图形库应用（和lua结合使用）
  • 网站建设计划表模板网络运营需要学什么专业
  • Scrapy 框架入门：高效搭建爬虫项目
  • 【JVM】详解 垃圾回收
  • 【前端魔法】实现网站一键切换主题
  • 电子 东莞网站建设wordpress 图片服务器配置
  • Spring Boot 3零基础教程，WEB 开发 通过配置类代码方式修改静态资源配置 笔记31
  • Vue模块与组件、模块化与组件化
  • SiriKali，一款跨平台的加密文件管理器
  • 构建优雅的 Spring Boot Starter：深入掌握国际化与配置覆盖的最佳实践
  • 网站建设的意义单页式网站
  • 易申建设网站兼职做ps网站
  • 力扣（LeetCode) ——11.盛水最多的容器（C++）
  • word插入页码？【图文详解】word怎么插入页码？word页码设置？
  • Leetcode 3719. Longest Balanced Subarray I
  • Rust unsafe
  • 辽宁省建设工程造价管理协会网站wordpress登陆按钮
  • 【pulldown-cmark】 初学者指南
  • [嵌入式系统-140]：Android以及其衍射版本都是基于Linux，Ubuntu、Rehat也都是基于Linux，异同进行比较。
  • GitLab 代码基础操作清单
  • 深度学习经典分类(算法分析与案例)
  • 做网站的叫什么百度seo引流怎么做
  • js，后端，css记录
  • 云服务器部署Python后端偶遇`ImportError`: 从依赖版本到Python升级的排错全攻略
  • 使用AI编程工具的“经济学”：成本控制与性能优化策略