具身智能嵌入式开发必学：C语言动态数组原理与工程实现

如果问一个打算入行具身智能的人，学习路线应该从哪里开始，网上十有八九会告诉你先学Python和PyTorch。这个答案不能算错，但你真跑到实验室里，面对一台机械臂、一块主控板、一堆传感器，就会发现另一套逻辑：底层的一切，几乎都是C语言写的。电机驱动、编码器读取、力矩反馈、通信协议解析、实时控制回路，这些对延迟和确定性极其敏感的环节，C语言是雷打不动的主角。所以这个系列的第一篇，我决定就讲C语言的数据结构与算法，并且从第一个数据结构——动态数组开始。

它不是最花哨的结构，却是所有后续结构的骨架。后面要写的栈、队列、哈希表、轨迹缓存、任务调度器，十有八九都建立在“自动扩容的连续内存”这个思路之上。把动态数组搞明白，等于同时点亮了内存布局、指针、深拷贝、均摊复杂度这几块硬技能。这篇笔记我会做三件事：第一，从具身智能的实际需求倒推，说明为什么第一站是C语言和数据结构；第二，手写一个可以直接抄进工程里的动态数组，把扩容策略、内存管理等关键决策掰开揉碎；第三，结合机械臂控制和传感器采集的场景，聊聊它到底用在哪，顺便把我踩过的坑都说清楚。

1. 为什么具身智能的学习路线，第一站是C语言和数据结构

1.1 具身智能的控制链路，天然要求“确定性”

具身智能这个词听起来新，但落地到工程上，就是一套感知、决策、执行的闭环。机械臂要抓取一个杯子，视觉模块识别物体的位姿，规划模块算出一条无碰撞轨迹，执行模块把轨迹拆解成各个关节的角度指令，电机驱动再按照指令输出力矩。这一整条链路里，视觉和规划上层用Python、PyTorch完全没问题，但真正把指令下发到电机的那一层，跑在裸机MCU或者带实时操作系统的嵌入式主控上。

嵌入式环境有几个硬约束。第一，内存小，动不动就是几十KB到几MB，没有GC帮你清理垃圾，自己申请的内存得自己还，忘了free就是内存泄漏，泄漏几次系统直接崩溃。第二，实时性强，控制回路的周期可能是500Hz甚至1kHz，意味着每个中断周期里必须完成采样、运算、输出，任务执行时间必须是确定的，不能因为一次内存回收让控制周期抖动。第三，C语言可以直接操作寄存器、指针，可以精确控制内存布局，没有语言运行时躲在背后做手脚。

很多搞深度学习的人第一次接触嵌入式代码会很不适应，觉得C语言太“原始”。但正是这种原始，给了你对硬件的绝对掌控力。具身智能项目想在物理世界里稳定工作，这一层就必须稳，而这一层几乎只能靠C语言扎实打底。

1.2 数据结构解决的是“数据流怎么被组织和调度”

具身智能系统里，数据不是一堆孤立的变量，而是持续流动的流。传感器以固定频率往外吐数据，控制算法要按帧消费这些数据；规划算法产生一串路径点，要临时存起来再顺序执行；日志系统要缓存最近的调试信息，等串口带宽空闲时再发给上位机。所有这些场景，都涉及到数据的存储、插入、删除、查找，这就是数据结构。

有人可能会问，我就拿数组随便用用不行吗？行，但会遇到很多边界问题：静态数组的长度写多少合适？写小了数据放不下，写大了浪费宝贵的RAM。而且数组本身不会告诉你现在装了多少数据，你得自己维护一个计数器。这些看似小的问题，在实时系统里会被放大成事故。数据结构课教的东西，本质上是把这类常见需求，总结成一套有明确理论保证、经过工程检验的通用容器和算法。动态数组就是这套知识体系的第一块基石。

2. 动态数组的本质：把“定长数组”升级为“自动扩容容器”

2.1 静态数组的三个老问题

C语言最基础的数组语法，int buf[100]，有两个硬伤。第一个是长度在编译期就定死了，运行时没法改。你估算要存100个点，结果路径规划器那天多生成了几个点，数据就溢出了。第二个是容量是足额分配的，哪怕你只存了一个点，100个int的空间也全部占用，这在RAM按KB算的嵌入式设备上是奢侈的。第三个是数组携带的信息太少，它只是连续内存的起始地址，长度得靠另一个变量单独维护，传递和操作都不方便。

动态数组的改进思路很简单直接：把“数组的内存空间”和“数组里实际存了几个元素”拆开，前者叫capacity，后者叫size。数组一开始只分配一小块空间，随着元素的增加按需扩容，size永远表示真实元素个数，capacity表示当前能装多少。这样就同时解决了定长、浪费、信息不足三个问题。

2.2 核心设计决策之一：size与capacity分离

我在教学和代码评审里见过很多“伪动态数组”，实现里只有一个长度字段，每次插入都重新malloc整块内存，然后把所有数据拷过去。这种做法从功能上没错，但性能差得离谱，因为每一次插入都涉及申请内存和全部拷贝，数据量一大，时间全浪费在搬移上。

正确做法是让size和capacity并肩作战。插入元素时，先判断size是否已经撞上capacity，只有满了才触发扩容。大部分插入操作都只是写一个元素、把size加一，时间复杂度O(1)。扩容不是每次插入都发生，而是“偶尔发生一次”，这就为均摊性能打下了基础。

2.3 扩容策略背后的数学：为什么是2倍或1.5倍

扩容时扩大多少，是个关键决策。最常见的选择是翻倍，capacity *= 2。为什么翻倍好？算一笔账。假设初始容量是1，依次插入1、2、4、8、16次扩容的总搬运量：第k次扩容前，容量已经是2^(k-1)，扩容时要把这2^(k-1)个元素拷贝到新内存。n次插入里，扩容发生的次数约log2(n)，总拷贝量大约是1+2+4+...+n/2 = n-1。也就是说，插入n个元素，额外拷贝的总量大约O(n)，摊到每次插入上，均摊复杂度O(1)。

如果换成固定步长扩容，每次只增加K个容量，那第m次扩容需要拷贝m*K个元素，n次插入的总拷贝量是O(n²/K)，均摊O(n)。这就完全不行了，数据一多性能直线下降。

翻倍策略的实现最简单，但缺点是内存利用率不高。假设需要存储1000个元素，容量可能一路涨到1024，刚够用，浪费不多；但要存1025个，容量直接跳到2048，空了近一半。所以有些工程采用1.5倍扩容，能更贴近实际需求，减少空间浪费，代价是计算扩容大小要处理整数运算和浮点倍率，代码稍微复杂。嵌入式项目里我会优先用2倍，省事，内存浪费可以通过后续的缩容步骤弥补。

2.4 缩容：处理不好会抖动的定时炸弹

缩容比扩容更讲究。简单粗暴的做法是：只要size < capacity就把容量缩到size。但如果在某个边界上反复横跳，系统就危险了。比如当前容量是1024，删几个元素剩600，缩到600；然后又插几个到601，触发扩容到1200；再删到600，再缩……每一次扩容和缩容都伴随内存申请和数据搬移，系统性能就被拖垮了，这就是典型的伸缩抖动。

工程上通常的做法是引入滞后区间，只在元素个数降到容量的四分之一以下时，才把容量缩为原来的一半。比如容量1024，元素个数小于256时才缩到512。这样扩容和缩容之间留出了缓冲区，避免了临界点的抖动。这一点在嵌入式系统上尤其重要，因为频繁realloc会让堆区产生大量碎片，时间一长malloc可能分配不出连续内存。

3. 从零手写：一份可以直接抄进工程里的动态数组代码

3.1 结构体与整体接口设计

先明确需求：这个数据结构要支持初始化、销毁、追加元素、插入元素、删除元素、随机访问、预留容量、缩容。我以int类型为例写实现，放在工程里时，把它换成你的实际数据类型即可，比如关节角度、力矩值、坐标点结构体。

#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { int *data; size_t size; size_t capacity; } DynArray;

为什么用size_t而不是int表示数量？因为数组长度和内存大小本质上是无符号量，size_t在64位平台上占64位，能表达的范围足够大，同时和malloc、realloc的参数量级一致，从根上避免符号比较的麻烦。

3.2 初始化与销毁：必须配对出现的内存管理

初始化函数负责把结构体里的字段清干净。销毁函数释放数据区内存，并把指针重新置空。置空这一步很容易被忽略，但它很重要，否则会产生悬垂指针，后续再次调用销毁函数时就会重复free同一个地址，直接崩溃。

void dynarray_init(DynArray *arr) { arr->data = NULL; arr->size = 0; arr->capacity = 0; } void dynarray_free(DynArray *arr) { free(arr->data); arr->data = NULL; arr->size = 0; arr->capacity = 0; }

在具身智能项目里，我习惯让每个持锁的中断服务程序或任务模块，把初始化写在启动阶段，把销毁写在任务退出阶段，确保每个init都有对应的free。你可以在结构体里加一个initialized标志位，但更推荐靠编码规范约束，不要为了图省事在运行时频繁地初始化和销毁动态数组。

3.3 核心扩容函数：reserve与grow

扩容的核心就是把数据搬运到更大的内存。C语言提供了realloc函数，它能在原地址上扩大空间，如果原地址后面连续内存不够，就另找一块更大的空间，并把原内容拷贝过去。

int dynarray_reserve(DynArray *arr, size_t new_capacity) { if (new_capacity <= arr->capacity) { return 0; } int *new_data = (int *)realloc(arr->data, new_capacity * sizeof(int)); if (new_data == NULL) { return -1; } arr->data = new_data; arr->capacity = new_capacity; return 0; }

注意这里的关键细节：先用一个临时指针承接realloc的返回值，确认不是NULL之后，再把它赋给arr->data。如果直接把arr->data传给realloc并把返回值赋给原指针，一旦realloc失败，原指针也会被清空，原来的内存地址就丢了，连抢救的机会都没有。这是动态数组实现里最经典的一个坑。

3.4 插入、删除与随机访问的完整实现

追加元素是最高频操作，代码很少，但浓缩了扩容判断和赋值两步。

int dynarray_push_back(DynArray *arr, int value) { if (arr->size >= arr->capacity) { size_t new_capacity = (arr->capacity == 0) ? 4 : arr->capacity * 2; if (dynarray_reserve(arr, new_capacity) != 0) { return -1; } } arr->data[arr->size] = value; arr->size++; return 0; }

初始容量为什么选4而不是1？因为很多实际场景下，一个动态数组的初始使用就能达到几个元素，直接给一个较小的初始空间，可以避免前几次插入都触发扩容。容量翻倍的起点也兼顾了内存浪费问题，不至于一开始就吃太多。

在数组中间插入元素要复杂一些。逻辑上先确保容量够用，然后把index及其之后的元素全部向后搬移一位，再写入新值。注意搬移必须从后往前，不然前面的元素会把后面的覆盖掉。

int dynarray_insert(DynArray *arr, size_t index, int value) { if (index > arr->size) { return -1; } if (arr->size >= arr->capacity) { size_t new_capacity = (arr->capacity == 0) ? 4 : arr->capacity * 2; if (dynarray_reserve(arr, new_capacity) != 0) { return -1; } } for (size_t i = arr->size; i > index; i--) { arr->data[i] = arr->data[i - 1]; } arr->data[index] = value; arr->size++; return 0; }

删除是插入的逆操作，把index之后的元素依次向前搬移一位，size减一。搬移方向与插入相反，是从前往后。

int dynarray_erase(DynArray *arr, size_t index) { if (index >= arr->size) { return -1; } for (size_t i = index; i < arr->size - 1; i++) { arr->data[i] = arr->data[i + 1]; } arr->size--; return 0; }

随机访问不需要专门写函数，直接用arr->data[index]就行。这体现了动态数组与链表最大的区别：连续内存存储意味着按下标访问任何元素都是O(1)，而且相邻元素在物理内存上也相邻，遍历时CPU缓存命中率高，这在频繁读传感器数据流的控制循环里非常关键。

3.5 一个可编译可运行的测试用例

写完API必须验证。下面这个测试程序覆盖了追加、自动扩容、随机访问、中间插入、中间删除和销毁清理的完整生命周期。

#include <assert.h> void test_dynarray(void) { DynArray arr; dynarray_init(&arr); for (int i = 0; i < 100; i++) { assert(dynarray_push_back(&arr, i * 2) == 0); } assert(arr.size == 100); assert(arr.capacity >= 100); assert(arr.data[50] == 100); assert(dynarray_insert(&arr, 10, 999) == 0); assert(arr.data[10] == 999); assert(arr.size == 101); assert(dynarray_erase(&arr, 10) == 0); assert(arr.data[10] == 20); assert(arr.size == 100); dynarray_free(&arr); assert(arr.data == NULL); } int main(void) { test_dynarray(); printf("all tests passed.\n"); return 0; }

实测下来，这段代码在gcc和clang下都能直接编译运行，没有警告，输出all tests passed.。把它编译进工程前，记得在调试版本里加上printf日志，看看扩容发生了多少次、最终容量是多少，这能帮你评估初始容量设得是否合理。

4. 在具身智能项目里，动态数组的五个典型应用场景

4.1 传感器时间序列的采集缓冲

机械臂关节里的力矩传感器通常以1kHz频率输出数据，控制算法要分析最近200毫秒内力矩的变化趋势，并提取峰值。用静态数组就得写死200个元素，一旦采样率调整，代码就要改。用动态数组则可以在初始化时reserve200个元素的空间，每次采样push_back，分析完后清空或保留滚动窗口。得益于reserve预分配的机制，push_back在运行过程中几乎不会触发扩容，性能损耗趋近于零。

4.2 运动规划路径点的轨迹缓存

路径规划算法生成的轨迹点数量是不确定的，一个简单的插值运动可能只有几十个点，避障搜索可能生成上千个候选点。这些点如果是笛卡尔坐标(x, y, z)，就需要一个结构体数组来存。把结构体塞进动态数组，扩展成泛型版本后，插入、删除、按顺序访问都会方便很多。而且轨迹点本身有一个特点是按下标随机访问的高频使用，比如样条插值计算要取第i、i+1、i+2个点，动态数组的连续内存恰好让这样的取指操作成为常数时间。

4.3 数据记录与回放

调试机械臂时，我最常用的工具就是把关节角度的实际值记录下来，事后画出来和期望值比对。记录长度未知，可能跑几十秒也可能跑十几分钟，动态数组是理想的记录容器。一个简单的做法是每收到一帧状态数据就push_back一个结构体，记录结束后一次性导出写进CSV或者串口发出去。配合缩容策略，在内存紧张的单片机上也能放心用。

4.4 感知模块候选目标列表

视觉感知模块在环境中识别出多个目标，每个目标有位置、置信度、类别。这些候选目标的个数不固定，识别算法可能这一帧找到3个，下一帧找到15个。动态数组天然适合存这种结果集合。更重要的是，感知结果后续常常要做非极大值抑制或者按置信度排序，这两类操作一个需要遍历访问，一个需要随机交换，动态数组比链表都更合适。

4.5 作为栈、队列、双端队列的底层容器

动态数组除了自己上阵，还是好多其他结构的底座。栈的入栈出栈，就是动态数组的尾部插入和尾部删除，复杂度都是O(1)。用两个动态数组还能拼出双端队列。哈希表的开地址法、邻接表实现图结构，也都依赖动态数组的“按需扩容、连续存储”特性。换句话说，动态数组不只是一个能用得上的工具，它是一把能造出更多工具的扳手。

5. 实操中绕不开的坑与排查方法

5.1 不要拿临时指针接realloc的返回值

前面代码里我用new_data临时承接realloc结果，这个是保命写法。实际工程里我见过太多人直接写arr->data = realloc(arr->data, ...)。一旦分配失败，arr->data就成了NULL，尚未释放的原内存也找不到了。在内存本来就很紧张的嵌入式设备上，扩容失败是真实会发生的事情，别让自己的代码连失败回溯的机会都没有。

5.2 扩容之后，老指针立即失效

动态数组扩容后，数据区地址大概率会变。如果你在扩容前拿到了arr->data的地址存到另一个指针变量里，扩容后这个旧地址就成了悬垂指针，再访问就是读脏数据甚至直接硬件错误。最典型的中招场景是：先用int *p = arr->data存下地址，之后在循环里调用dynarray_push_back触发了扩容，循环里继续用p读写数据。排查这类问题，可以在每次push_back之后重新获取arr->data地址，或者强制要求：对动态数组的引用访问，必须通过arr->data + index现场计算，不要长期缓存地址。

5.3 浅拷贝会把结构体里的指针成员复制出悬垂麻烦

如果数组元素本身是结构体，而结构体内部有char *name这样的指针成员，那么memcpy式地复制数组内容时，只是拷了指针值，两个元素会指向同一块字符串内存。一旦其中一个被删除、释放，另一个就成了悬垂指针。这个问题在把动态数组当通用容器来用时几乎必踩。解决方案有两种：一是动态数组存嵌套结构体时，元素类型选择值类型或者带深拷贝语义的类型；二是自己管理好元素的生命周期，删除元素之前先处理内部的指针成员，或者干脆在结构体里用定长字符数组替代指针。

5.4 缩容阈值的设置是门手艺

缩容不是越积极越好。容量1024、元素600时就缩到600，接着再插入到601又扩容到1200，一来一回浪费了大量搬移时间。我自己的默认策略是：只有当size降到capacity的四分之一以下时才触发缩容，并且只缩到容量的一半。这套“滞后区间”策略能有效避免抖动。顺带一提，如果你的控制循环对抖动零容忍，那就尽量在主循环之外做扩缩容，不要在中断服务函数里调用malloc和realloc，它们的时间开销是不确定的。

5.5 遍历时删除元素会让索引凌乱

用动态数组做扫描+删除时，常见错误是正序遍历，删掉一个元素后下标继续加一，结果跳过了紧接着的下一个元素。正确做法有两种：从后往前遍历删除，或者删除后下标回退一位。前者代码更简洁，推荐优先使用。另外，删除过程中频繁搬移元素是O(n)操作，如果一次要删掉大量元素，不如直接双指针原地过滤，把需要保留的元素往前覆盖，最后统一调整size，性能会好很多。

6. 动态数组之后，下一步学什么

我个人在实际操作里的体会是，动态数组是C语言和数据结构之间的一座桥。它逼着你学会和内存指针打交道，理解什么是容量、什么是大小，也理解了为什么哈希表和搜索树在工程上要用“负载因子”这类概念来管理空间。下一篇可以接着写链表，比较一下有序插入场景下链表的优势和缓存局部性的劣势；再往后就是栈和队列，对应到任务调度和通信缓冲；然后是哈希表，对应到SLAM里的特征匹配和字典存储。

如果你是冲着具身智能来的，学数据结构的节奏不建议太快。每学一个结构，就想想它在你手头的传感器数据流、控制指令序列、路径点集合里能用在哪。动态数组这个东西，看起来平平无奇，但它在嵌入式世界里到处都是，从bootloader到实时内核，从驱动缓冲到应用调度。把它吃透了，C语言的地基就算打下去了，后面写什么结构都会顺手很多。