10、抽象数据类型（ADT）：用结构体封装数据、不透明指针（Opaque Pointer）技术、实战：实现一个动态数组模块
各位同学，欢迎来到第十讲。今天我们要聊的话题，是C语言模块化编程里一个非常核心的概念——抽象数据类型，也就是ADT。说白了，就是怎么把数据和操作数据的函数，打包成一个黑盒子，只给用户看接口，不让他们碰内部结构。
为什么要这么做？我刚开始做嵌入式开发那会儿，也喜欢把所有结构体成员都暴露在头文件里，觉得这样方便。结果有一次，一个同事直接修改了我结构体里的一个内部计数器，导致整个状态机跑飞了。从那以后，我就深刻理解了封装的重要性。
10.1 什么是抽象数据类型？
抽象数据类型，英文叫Abstract Data Type，简称ADT。它包含两部分：
- 数据：用结构体封装起来
- 操作：一组专门操作这些数据的函数
用户只需要知道“我能对这个类型做什么”，而不需要知道“这个类型内部是怎么存的”。这就是信息隐藏的精髓。
核心思想：接口与实现分离。接口稳定，实现可以随时换。
举个例子，你用一个动态数组模块，你只需要调用 dynarray_push() 往里面加数据，调用 dynarray_get() 取数据。至于底层是用链表还是用连续内存，你根本不用关心。这就是ADT的魅力。
10.2 不透明指针技术
不透明指针，英文叫Opaque Pointer，是实现ADT的关键技术。它的做法很简单：
- 在头文件里，只声明结构体的名字，不定义它的成员
- 在源文件里，才完整定义结构体
用户只能通过指针来操作这个结构体，但看不到里面的任何成员。就像你拿着一个遥控器，知道按哪个键能做什么，但遥控器内部电路你看不到。
我的习惯：我一般把不透明类型命名为 xxx_t，比如 dynarray_t。这样一看就知道是个类型，不是变量。
10.2.1 头文件写法示例
// dynarray.h
#ifndef DYNARRAY_H
#define DYNARRAY_H
#include <stddef.h> // size_t
// 前向声明：告诉编译器有这么一个结构体，但细节不告诉你
typedef struct dynarray dynarray_t;
// 创建和销毁
dynarray_t* dynarray_create(size_t capacity);
void dynarray_destroy(dynarray_t* arr);
// 基本操作
int dynarray_push(dynarray_t* arr, int value);
int dynarray_pop(dynarray_t* arr, int* out_value);
int dynarray_get(const dynarray_t* arr, size_t index, int* out_value);
size_t dynarray_size(const dynarray_t* arr);
#endif // DYNARRAY_H
你看，用户拿到这个头文件，只知道有 dynarray_t 这么个东西，但不知道里面有什么。他只能通过我提供的函数来操作。嗯，这就是封装。
10.2.2 源文件实现
// dynarray.c
#include "dynarray.h"
#include <stdlib.h> // malloc, free
// 完整定义：只有这里才知道结构体长什么样
struct dynarray {
int* data; // 数据缓冲区
size_t size; // 当前元素个数
size_t capacity; // 容量
};
dynarray_t* dynarray_create(size_t capacity) {
dynarray_t* arr = (dynarray_t*)malloc(sizeof(dynarray_t));
if (!arr) return NULL;
arr->data = (int*)malloc(sizeof(int) * capacity);
if (!arr->data) {
free(arr);
return NULL;
}
arr->size = 0;
arr->capacity = capacity;
return arr;
}
void dynarray_destroy(dynarray_t* arr) {
if (arr) {
free(arr->data);
free(arr);
}
}
int dynarray_push(dynarray_t* arr, int value) {
if (!arr) return -1;
if (arr->size >= arr->capacity) {
// 容量不够，自动扩容
size_t new_cap = arr->capacity * 2;
int* new_data = (int*)realloc(arr->data, sizeof(int) * new_cap);
if (!new_data) return -1;
arr->data = new_data;
arr->capacity = new_cap;
}
arr->data[arr->size++] = value;
return 0;
}
int dynarray_get(const dynarray_t* arr, size_t index, int* out_value) {
if (!arr || !out_value) return -1;
if (index >= arr->size) return -1;
*out_value = arr->data[index];
return 0;
}
size_t dynarray_size(const dynarray_t* arr) {
return arr ? arr->size : 0;
}
避坑指南：我曾经在项目里遇到过一个bug，用户直接通过指针偏移访问了结构体内部成员，绕过了所有检查。后来我强制把所有结构体定义都放到.c文件里，头文件只留前向声明。从此再也没出过类似问题。
10.3 实战：实现一个动态数组模块
好，理论讲完了，我们来动手。下面是一个完整的动态数组模块，支持自动扩容、随机访问、尾部插入和删除。
10.3.1 模块结构
一个标准的ADT模块，通常包含三个文件：
| 文件 | 作用 |
|---|---|
| dynarray.h | 公开接口，不透明类型声明 |
| dynarray.c | 内部实现，结构体完整定义 |
| main.c | 用户代码，只包含头文件 |
10.3.2 用户如何使用
// main.c
#include "dynarray.h"
#include <stdio.h>
int main() {
// 创建一个容量为4的动态数组
dynarray_t* arr = dynarray_create(4);
if (!arr) {
printf("创建失败\n");
return -1;
}
// 插入数据
for (int i = 0; i < 10; i++) {
if (dynarray_push(arr, i * 10) != 0) {
printf("插入失败\n");
break;
}
}
// 读取数据
int val;
for (size_t i = 0; i < dynarray_size(arr); i++) {
if (dynarray_get(arr, i, &val) == 0) {
printf("arr[%zu] = %d\n", i, val);
}
}
// 销毁
dynarray_destroy(arr);
return 0;
}
你看，用户完全不需要知道内部有 data、size、capacity 这些成员。他只需要调用我提供的函数。这就是抽象数据类型的威力。
10.4 知识体系结构图
下面这张图，展示了本章的核心逻辑：
10.5 为什么ADT这么重要？
你想想看，在嵌入式系统里，代码复用是硬需求。一个动态数组模块，今天用在传感器数据采集，明天用在通信协议栈，后天用在日志系统。如果每次都要重新写一遍，那得多累？
ADT的好处，我总结了几点：
- 封装性：内部实现随便改，接口不变，用户代码不用动
- 可测试性：模块独立，可以单独写单元测试
- 可维护性：出bug了，只需要改一个地方
- 安全性：用户没法乱改内部数据，减少意外
我的经验：在团队协作中，我习惯先定好接口文档，再分头实现。接口定了就不要轻易改。改接口就像改合同，牵一发而动全身。
10.6 总结
抽象数据类型，说白了就是“把数据藏起来，只给操作”。不透明指针是实现它的核心技术。通过今天这个动态数组模块，你应该能感受到ADT带来的好处。
嗯，最后提醒一句：不要为了封装而封装。如果你的模块只有几个简单的变量，没必要搞ADT。但一旦逻辑复杂起来，或者需要多人协作，ADT就是你的好朋友。
公众号:蓝海资料掘金营，微信deep3321