接触 C 语言的人第一个绕不开的概念就是数组。我这些年做嵌入式底层、写算法题、带新人几乎每个项目都跟数组脱不了关系。它简单到可以用一句话讲完把同一类型的元素按顺序排在一段连续的内存里。可一旦真开始写初始化、越界、指针纠缠、动态扩容、字符串处理每一处都藏着坑。这篇文章是我在 C 语言数组上的实战笔记适合刚学完基本语法的同学也适合那些写代码时总被“莫名其妙的乱码”“段错误”折磨的工程师。我会从数组的内存本质讲起逐步过渡到与指针的关系、动态数组的实现再结合冒泡排序、字符串逆序、循环队列这些经典场景最后分享几个实用的调试技巧。1. 数组的本质一块连续内存的管理艺术1.1 从声明到底层编译器眼中的数组先看最简单的声明int a[10];。这行代码告诉编译器请给我分配一块连续的内存能放下 10 个 int。在常见的 32 位或 64 位平台上一个 int 是 4 字节这 10 个元素就占 40 字节而且这 40 个字节是紧紧挨在一起的。第 i 个元素的地址就是首地址加上i * sizeof(int)这个公式是数组一切行为的底层逻辑。因为连续所以数组有两个很大的优势。第一是缓存友好CPU 加载内存时是一块块读的你顺序遍历数组时相邻数据大概率都在同一个缓存行里速度比链表快不少。第二是配合底层函数非常方便memcpy、memset、strcpy这些函数操作的就是连续内存传入数组名就能直接按字节处理整块区域。编译器眼中的数组名其实是一个“指向首元素的地址常量”。注意是常量不是变量你不能写a或者a b。但在某些场景下数组名会“退化”成指针最典型的就是函数传参这一点后面要重点讲。还有一个容易搞混的知识点sizeof(a)返回的是整个数组占用的字节数而不是首元素的字节数。比如int a[10];sizeof(a)是 40sizeof(a[0])是 4两者一除就能得到元素个数 10。这是 C 语言里最常用的数组长度求法我在代码里经常写int a[] {1, 2, 3, 4, 5}; int n sizeof(a) / sizeof(a[0]);但请注意这个写法只适用于“当前作用域里定义的真实数组”。一旦数组作为参数被传到函数里sizeof的结果就完全不一样了我会在第三章专门讲。1.2 索引与偏移为什么下标从 0 开始新手最常问的一个问题为什么数组下标要从 0 开始而不是从 1 开始答案其实很简单数组下标本质上是“偏移量”。a[i]在编译器眼里就是*(a i)也就是“从首地址向后偏移 i 个元素”。第一个元素的偏移量是 0所以下标自然就是 0。如果从 1 开始每次访问都要多做一个“减 1”的操作虽然现代指令集已经不太在乎这一条减法但 C 语言诞生时效率就是生命这个设计从汇编时代一直延续到今天。理解这个偏移思想很多代码就不会看晕了。比如a[i]和i[a]是完全等价的因为*(a i)和*(i a)是同一个地址计算。这个冷知识看起来很“炫技”但它能帮你真正理解下标就是地址偏移。再比如a[i]和a[i]前者先把 i 自增再取下标后者先取当前 i 的下标再自增。个人建议写这种复杂下标时宁可拆成几行也不要为了代码短而牺牲可读性团队协作时尤其如此。索引的边界问题也是从这里来的。一个长度为 n 的数组下标的合法范围是0到n-1。n不在合法范围内它是偏移量的上限不是有效下标。很多越界 bug 都是因为写循环时用了而不是这个习惯问题我会反复强调。2. 数组初始化、扩容与越界三个最容易翻车的操作细节2.1 初始化方式全解析数组初始化看似简单实际有特别多的细节。我见过不少工作两三年的程序员在“局部数组是否清零”这个问题上还会翻车。先看一张对比表初始化方式效果注意事项int a[5];局部元素值不确定一般是栈上的随机垃圾值必须手动初始化int a[5] {0};全部初始化为 0C 语言约定部分初始化时剩余元素自动置 0int a[5] {1,2,3};前三个是 1,2,3后两个是 0部分初始化很好用但容易忘掉补零规则int a[] {1,2,3};自动推导长度为 3推荐在常量列表场景使用不用担心长度写错static int a[5];全部初始化为 0静态存储区本来就是零初始化char s[] hello;长 6 字节末尾有\0字符串常量自带结束符char s[5] hello;长 5 字节没有\0这是高危代码后续用strlen/puts会越界一个很容易踩的坑是char s[5] hello;。表面上看字符串 hello 正好 5 个字符但字符串字面量实际上在末尾还有一个不可见的\0总长度是 6。如果你硬塞进 char[5]编译器会把这个结束符丢掉之后所有依赖字符串结束符的函数都会读过头。正确做法是让编译器自动推导长度char s[] hello;。数组整体赋值是 C 语言的一大痛点。不能写int b[5] a[5];也不能写a b;数组不是左值不能整体赋值。想复制数组一般用循环逐元素拷贝或者直接memcpy(a, b, sizeof(a));。同一个结构体可以直接赋值那是因为结构体是可复制类型数组没有这个待遇。2.2 数组“增加元素”的真实玩法C 语言的数组长度是固定的物理上不能“增加”。那为什么网上总有人问“数组怎么增加元素”其实他们需要的是两种东西一种是在逻辑上向数组里新增数据另一种是动态扩容。先说逻辑增加。假设你事先声明了一个容量足够大的数组然后维护一个size变量记录当前实际用了多少个元素int data[100]; int size 0; size; // 逻辑长度加 1 data[size - 1] 42; // 在末尾放新元素这里的“数组”还是那 100 个元素你只是没有用满而已。写代码时要严格区分“容量 capacity”和“长度 size”。容量是这块数组最多能放多少长度是你目前已经放进去了多少。很多 bug 就是把这两个混在一起循环遍历时用capacity当size一下子读到一堆未初始化的垃圾值。再说物理扩容。当容量不够时就要用到动态内存了。标准做法是reallocint *append(int *arr, int *size, int *cap, int val) { if (*size *cap) { int newCap (*cap 0) ? 4 : (*cap) * 2; int *tmp realloc(arr, newCap * sizeof(int)); if (tmp NULL) { return NULL; // 扩容失败原来的 arr 仍然有效 } arr tmp; *cap newCap; } arr[(*size)] val; return arr; }这个函数看着简单但有几个关键点值得说说。为什么用临时变量tmp来接realloc的返回值因为realloc失败时会返回 NULL但原来的内存块并没有被释放。如果你直接写arr realloc(arr, newCap * sizeof(int));一旦失败arr就被覆盖成 NULL原来的内存再也找不回来这就是经典的内存泄漏。先用tmp判断成功后再赋值是最稳妥的写法。扩容倍数为什么选 2 而不是每次加 1这涉及均摊复杂度。每次加 1插入 n 个元素的时间是 O(n²)因为每次都要把旧数据搬到新内存。每次翻倍搬家次数大概是 log n 次均摊下来每次插入接近 O(1)。当然翻倍也有代价如果数组很大会一次性多申请很多内存可能造成浪费。实际项目中有人选 1.5 倍有人选 2 倍但核心思路都是“指数扩容”而不是“线性加 1”。顺带一提C99 引入的变长数组VLA也算一种“可变数组”int n; scanf(%d, n); int a[n];它允许数组长度在运行时确定但它分配在栈上函数退出就自动释放。如果 n 来自用户输入且没有上限很容易栈溢出。我一般只在长度可控的小场景里用 VLA生产代码更倾向用malloc在堆上动态分配。2.3 越界访问不报错才是最可怕的数组越界是我最想重点强调的问题。C 语言设计追求性能不会在每次数组访问时做边界检查。也就是说a[10]如果你只声明了 5 个元素程序照样会去访问那块内存只是那块内存根本不属于你。越界读还算好最多读出一个错误的垃圾值越界写才是真正致命的。我调过很多“变量值莫名其妙被改”的 bug最后定位到是某个数组越界写把相邻局部变量的内存覆盖了#include stdio.h int main(void) { int a[5] {0}; int b 100; for (int i 0; i 5; i) { // 写成 i 5 是越界 a[i] i; } printf(b %d\n, b); // b 可能已经不是 100 了 return 0; }在这个例子里当i 5时a[5]越界写而栈上紧挨着a的很可能就是变量b的地址空间b就被覆盖成了 5。程序不一定会崩溃但运行结果已经错了。更严重的情况是覆盖函数返回地址程序会在某个时刻直接崩溃而且崩溃位置离出错的代码非常远极难排查。怎么防第一循环边界一律写成i n不要写i n第二尽量用 AddressSanitizerASan编译运行它能在越界发生的第一时间弹出报告告诉你具体是哪一行崩的gcc -g -fsanitizeaddress -o test test.c ./test开了 ASan上面那个i 5的例子会直接报stack-buffer-overflow定位到a[i] i;那一行。我每周都会用 ASan 跑一遍核心代码能省掉大量调试时间。3. 数组与指针的关系C语言数组最难跨越的一道坎3.1 数组名不是指针但传参时会“退化”很多人把数组和指针划等号其实不完全对。在大多数表达式里数组名确实可以当作指向首元素的指针使用所以才有arr[i]等价于*(arr i)。但有三个场景能看出数组名不是指针sizeof(arr)返回整个数组大小arr的类型是“指向整个数组的指针”以及数组名不能自增自减。真正让无数人翻车的是函数传参时的“退化”。看这段代码#include stdio.h void printSize(int a[]) { printf(in function: %zu\n, sizeof(a)); } int main(void) { int a[10]; printf(in main: %zu\n, sizeof(a)); // 输出 40 printSize(a); // 输出 8 或 4 return 0; }在main里sizeof(a)是 40因为它是真实数组。但一进printSizesizeof(a)就变成了指针的大小64 位平台是 8。这是因为函数声明里的int a[]在编译器看来就是int *a数组名作为参数时退化成指针数组长度信息完全丢失。所以任何想在函数内部知道数组长度的需求都必须额外传一个长度参数。这几乎是 C 语言数组使用的铁律void printArray(int a[], int n) { for (int i 0; i n; i) { printf(%d , a[i]); } printf(\n); }再补充一个非常经典的地址运算题int a[5]; printf(%p %p\n, a, a 1); // 相差 4 字节一个 int printf(%p %p\n, a, a 1); // 相差 20 字节整个数组a 1指向下一个元素a 1指向整个数组的末尾。这个知识点在底层内存分析时很有用也经常出现在面试题里。3.2 指针数组与数组指针别把声明读反了“指针数组”和“数组指针”这两个词是 C 语言里最绕的概念之一。我每次带新人都会让他们先背一句口诀优先级和括号说了算。int *p[3];p先和[3]结合所以p是一个数组数组里存了 3 个int *这叫指针数组。int (*p)[3];括号让p先和*结合所以p是一个指针它指向了一个含有 3 个 int 的数组这叫数组指针。指针数组最常见的应用是字符串数组char *fruits[] {apple, banana, cherry}; for (int i 0; i 3; i) { puts(fruits[i]); }这里fruits中每个元素都是char *指向一个字符串常量。“apple”和“banana”的长度不同用指针数组存储正好不用关心每行长度省内存。但要注意这些字符串常量一般存放在只读区不能修改。数组指针则常用于二维数组的函数参数。比如一个int a[2][3]类型就可以写成int (*p)[3]。如果你写函数void f(int a[][3], int rows)编译器也会把它调整为void f(int (*a)[3], int rows)。写声明时如果自己都容易混建议用typedef给自己留一条后路typedef int Row3[3]; // Row3 是一个 int 数组类型 Row3 a[2]; // 相当于 int a[2][3]3.3 二维数组、二维字符数组与指针的寻址二维数组在内存里不是“二维平面”而是一段线性排列。int a[2][3]的排列顺序是第一行的三个元素、第二行的三个元素全部连续存放。对编译器来说a的类型是int (*)[3]a[0]的类型是int *指向第一行首元素a[1]指向第二行首元素。访问a[i][j]时实际上展开为*(*(a i) j)先跳到第 i 行再从那行首地址偏移 j 个元素。理解这个展开式就能明白为什么int **和二维数组不是一回事。int **期望的是一块内存里面存的是一个个int *指针而二维数组的内存里存的是连续的元素第 i 行的首地址是由元素个数算出来的不是从某块指针区域读取的。直接写int **p a;然后访问p[i][j]大概率崩溃。二维字符数组在存储“一批字符串”时有两种选择char names[3][20]; // 每个字符串最长 19 字符末尾有 \0 char *names[3]; // 只存指针字符串在别处第一种适合你需要修改字符串内容、或者要按字典序排序后原地交换字符的时候缺点是每行长度固定若字符串长短差异大浪费空间。第二种适合只读字符串常量、或者指向动态分配字符串的时候缺点是修改和排序时需要额外管理内存。选择哪种取决于后续操作是“改字符”还是“换指针”。我写命令行解析工具时默认用char *args[MAX_ARGS]因为参数都是只读字符串这样最省事。4. 动态数组与可变数组的实现突破固定长度限制4.1 用 malloc 族函数实现动态数组数组长度在编译期确定的限制很多时候受不了。比如要读一个文件文件里有多少个数字读完才知道。这时候就要在堆上动态分配内存。最基础的模式是#include stdio.h #include stdlib.h int main(void) { int n; if (scanf(%d, n) ! 1) { return 1; } int *arr malloc(n * sizeof(int)); if (arr NULL) { return 1; } for (int i 0; i n; i) { arr[i] i * i; } free(arr); return 0; }这里有几个细节值得说一下。第一malloc的参数用n * sizeof(int)我习惯写成n * sizeof(*arr)这样将来如果把int改成long不用改sizeof里的类型少一处出错机会。第二malloc返回的内存不会自动清零里面是垃圾值。如果你需要一个全零数组用calloc(n, sizeof(int))它会在分配的同时把内存清零。第三堆内存不会因为函数返回而释放必须手动free这是动态数组的代价。动态数组的好处是不用提前知道数据量。坏处是你要承担内存管理的责任。漏一次free可能就泄漏一次内存多free一次可能直接崩溃。所以我一向建议谁分配谁释放函数里分配的内存要么在函数内释放要么在函数返回前明确交给调用方并且要把释放责任写在注释里。4.2 封装一个可自动扩容的数组结构体裸手管理malloc和realloc很容易出错更工程化的做法是把“数组指针、长度、容量”封装成一个结构体。这个模式在 C 里就是std::vector的雏形用 C 语言也可以做一个简单版本#include stdio.h #include stdlib.h typedef struct { int *data; int len; int cap; } IntVector; void ivInit(IntVector *v) { v-data NULL; v-len 0; v-cap 0; } void ivPush(IntVector *v, int x) { if (v-len v-cap) { v-cap (v-cap 0) ? 4 : v-cap * 2; int *tmp realloc(v-data, v-cap * sizeof(int)); if (tmp NULL) { perror(realloc); exit(1); } v-data tmp; } v-data[v-len] x; } void ivDestroy(IntVector *v) { free(v-data); v-data NULL; v-len 0; v-cap 0; } int main(void) { IntVector v; ivInit(v); for (int i 0; i 100; i) { ivPush(v, i); } for (int i 0; i v.len; i) { printf(%d , v.data[i]); } printf(\n); ivDestroy(v); return 0; }这个封装最大的好处是把“长度”和“容量”变成约定调用方不用再关心size和cap传引用的问题。ivPush函数内部判断是否需要扩容用户只管往里面塞数据。容量翻倍的策略也集中在一个地方以后想改成 1.5 倍只改一个函数即可。实际项目中还可以继续扩展比如加一个ivReserve预分配接口提前指定容量减少后续多次realloc带来的拷贝或者加一个ivGet带边界检查的访问函数方便调试。这个思路不仅适用于 int把类型换成char、结构体原理完全一样。在 C 语言里“代码复用靠 struct 和函数”而不是靠模板所以我更愿意花时间把这些基础容器打磨好后面所有项目都能复用。4.3 内存生命周期、内存碎片与释放策略动态数组最怕的是“生命周期搞不清楚”。最常见的错误是函数返回一个局部数组的指针int *bad(void) { int a[100]; return a; // 错a 是栈内存函数返回后失效 }返回后你得到的是一个悬垂指针指针指向的栈内存随时可能被下一个函数调用覆盖。正确做法有几种调用方传入一个数组缓冲区函数内用malloc分配并返回堆指针或者用static修饰局部数组但要注意它不是线程安全的。这三种我按场景分开用最常用的是“调用方传缓冲区”因为所有权最清晰。内存碎片也是一个值得注意的点。如果频繁地对一个很小的数组做realloc每次加一点点堆上会留下大量细碎的空洞。操作系统管理内存是分页的碎片太多会导致明明有空闲内存却申请不到大块连续内存。解决方案就是前面说的指数扩容一次扩大足够的量减少申请次数。另一个方案是预估规模提前malloc一大块用完再释放。动态数组结束后务必free并置空指针free(arr); arr NULL;置空的意义在于即使后续不小心再次释放释放 NULL 是安全的如果忘记置空就可能出现 double free这是崩溃和安全性漏洞的高频来源。5. 数组的典型应用排序、字符串逆序与环形队列实现5.1 用数组实现冒泡排序与数组去重学 C 语言几乎每个人都写过冒泡排序。它虽然效率不高但用来理解数组下标交换特别直观。冒泡排序的核心思想每一趟把相邻的两个元素比较如果顺序不对就交换一趟下来最大的元素就像气泡一样浮到末尾。void bubbleSort(int arr[], int n) { for (int i 0; i n - 1; i) { for (int j 0; j n - 1 - i; j) { if (arr[j] arr[j 1]) { int tmp arr[j]; arr[j] arr[j 1]; arr[j 1] tmp; } } } }为什么内层循环的边界是n - 1 - i因为每完成一趟最后的 i 个元素已经有序不需要再比较。这个边界写成n - 1也能跑但会多做很多无意义比较。在实际面试或笔试里冒泡排序往往不是最优解但它是检查基本功的好题目能清楚地写出双层循环边界、交换逻辑基本说明数组的索引掌握过关了。数组去重也可以用类似的数组操作实现。最简单的做法是先排序然后相邻比较跳过重复元素。我自己写去重时常用双指针技巧int removeDuplicates(int arr[], int n) { if (n 0) { return 0; } int k 1; // 不重复元素数量 for (int i 1; i n; i) { if (arr[i] ! arr[k - 1]) { arr[k] arr[i]; } } return k; }这个函数的思路是维护一个慢指针 kk 之前的数组是已经去重后的部分快指针 i 遍历整个数组。当arr[i]和它前面的不同就把它放到 k 位置然后 k 自增。这样不用额外数组原地去重空间复杂度 O(1)。前提是数组有序。如果想保持原顺序去重可以加一个哈希表或标记数组那是另一套方案。5.2 字符串逆序和字符数组的边界问题字符串在 C 语言里就是字符数组只不过末尾多了一个\0。逆序字符串是一个经典题目看起来很简单但能难倒一大片人主要因为两个坑一是忘了字符串末尾有结束符二是把字符串常量当可修改数组。先看基本实现#include stdio.h void reverseString(char s[]) { int len 0; while (s[len] ! \0) { len; } for (int i 0, j len - 1; i j; i, j--) { char tmp s[i]; s[i] s[j]; s[j] tmp; } } int main(void) { char s[] hello; reverseString(s); puts(s); // 输出 olleh return 0; }这里如果用strlen(s)求长度也可以但自己写一个 while 循环更能看清字符数组的边界。h,e,l,l,o,\0长度是 5最后一个字符下标是 4所以双指针的右指针从len-1开始。最大的坑在于初始化方式。我见过有人这样写char *s hello; reverseString(s); // 崩溃这会崩因为hello是字符串常量通常存放在只读段。你拿char *指向它可以读但不可以写。一旦尝试修改程序直接段错误。需要可修改的字符串必须用数组初始化char s[] hello;。这个区别在笔试里考了无数遍在项目里也坑了无数人。另一个容易翻车的点是scanf读字符数组。如果新手直接写scanf(%s, buf);而buf只有 10 个字节输入却很长就会越界写。解决办法要么限制读取宽度char buf[20]; scanf(%19s, buf); // 只读 19 个字符留 1 个放 \0要么用fgets(buf, sizeof(buf), stdin);。这已经不仅是数组问题了更是安全意识问题。所有从外部输入写入字符数组的操作都必须明确最大长度。5.3 用数组实现循环队列与文件缓冲区数组的经典应用里环形队列非常值得讲。有个很常见的题目描述是这样的假设以数组q[M]存放循环队列中的元素同时以rear和length分别指示环形队列中的队尾和长度。用这种方式能巧妙解决“队空”和“队满”的区分问题。环形队列的本质是用一个固定长度数组通过下标取模运算实现“物理上循环”的逻辑队列。比如数组长度 M入队时队尾下标变成(front length) % M出队时队头下标变成(front 1) % M。用length变量则不需要额外留一个空位来区分队空队满。下面是一个简单的环形队列实现#include stdio.h #include stdbool.h #define M 8 typedef struct { int data[M]; int front; int length; } ArrayQueue; bool queueIsFull(const ArrayQueue *q) { return q-length M; } bool queueIsEmpty(const ArrayQueue *q) { return q-length 0; } bool enqueue(ArrayQueue *q, int x) { if (queueIsFull(q)) { return false; } int tail (q-front q-length) % M; q-data[tail] x; q-length; return true; } bool dequeue(ArrayQueue *q, int *x) { if (queueIsEmpty(q)) { return false; } *x q-data[q-front]; q-front (q-front 1) % M; q-length--; return true; }这个实现的好处是入队时不需要单独维护rear变量直接通过front length算出队尾位置取模后就是下一次要写入的下标。队列空和满的判断异常清晰不会出现传统front rear时“不知道空还是满”的困惑。这种“定长数组 读写指针或计数”的模式在底层开发里非常常见。文件缓冲区、串口接收 FIFO、音频数据缓冲都是类似的结构。拿文件缓冲区来说系统读文件不会一次只读一个字节而是用一块数组作为缓冲区记录 buf 里已读的位置和长度按需取用。理解数组在这类场景中的核心作用基本上就理解了 C 语言系统编程的一半内存是连续的读写是偏移的状态是记录的。6. 数组调试与避坑指南GDB、AddressSanitizer和常见错误速查6.1 用 GDB 查看数组和捕捉越界修改很多初学者遇到数组问题都是靠加打印语句“盲猜”这不仅慢还容易漏。学会用调试工具效率会高很多。最基础的是 GDB。假设代码已经用-g编译gcc -g -o test test.c gdb ./test在 GDB 里可以用print直接查看数组内容(gdb) break main (gdb) run (gdb) print arr[0] (gdb) print arr[0]10print arr[0]10是 GDB 的数组切片语法意思是从arr[0]开始连续打印 10 个元素。当数组很长时这个命令非常实用比for循环手动打印方便得多。如果怀疑某个数组元素被意外修改可以用 watch 命令设“硬件观察点”(gdb) watch arr[3]当arr[3]的值发生变化时GDB 会立刻停下并告诉你是在哪一行、哪条指令修改了它。我在排查“一个变量值莫名其妙变成 0”这种问题时这招相当有效。不过 GDB 定位数组越界的能力有限因为它只能看到“某个变量被改了”看不到“哪段越界写改了它”。这时候我更推荐 AddressSanitizer。编译时加一个参数程序就能在数组越界的第一现场直接报告gcc -g -fsanitizeaddress -fno-omit-frame-pointer -o test test.c ./testASan 会直接输出类似ERROR: AddressSanitizer: stack-buffer-overflow的报告并带出出错代码的行号。这几乎已成为我写 C 代码的标准调试流程。平时开发用 ASan发布版本再关掉因为 ASan 会拖慢运行速度。6.2 数组常见问题速查表下面这张表是我在实际调试和新手咨询中总结出的高频问题几乎每一个都对应一个真实踩坑案例现象根本原因解决方案函数内sizeof(arr)变小数组参数退化为指针额外传入数组长度参数修改char *s hello崩溃字符串常量位于只读段改为char s[] hello访问a[n]没有报错但结果不对C 数组没有边界检查检查循环边界开启 ASan把二维数组传给int **崩溃二维数组和二级指针布局不同用int (*p)[N]realloc后原数组丢失返回值直接覆盖了原指针用临时变量保存返回值函数返回局部数组指针返回了栈上地址用malloc或调用者提供缓冲scanf(%s, buf)输入过长没有限制写入长度用scanf(%Ns, buf)或fgets数组整体赋值报错数组不是可赋值类型用memcpy或循环VLA 数组过大导致栈溢出在栈上分配大块内存改用堆上的动态数组这些问题的共同点都是“数组在内存里的真实行为”和“直觉预期不一致”。想在 C 语言里少踩坑就要养成一个习惯写数组操作前先问自己一句“这片内存是谁的长度是多少边界在哪”6.3 实操心得与个人建议最后聊几句我自己这几年写数组代码的经验。我写循环遍历数组时几乎强制自己用i n而不是i n。看起来只是符号差别但这个习惯能直接消灭一半的越界 bug。如果数组长度是动态的我还会在循环前加一条边界断言比如if (n 0) return;让错误尽早暴露而不是等数组往后越界才爆炸。数组作为函数参数时我习惯写成“地址 长度”成对出现。任何函数如果只接收数组名而不接收长度我都会先打个问号它怎么知道数组有多长除非这个数组是固定长度的全局数组或者字符串可以靠\0判断结束否则没有长度参数的数组函数就是一个隐患。很多内存相关的问题我都是靠 ASan 和 Valgrind 定位的。Valgrind 可以查malloc和free的匹配情况valgrind --leak-checkfull ./test它会列出所有泄漏的内存块还能告诉你是在哪一行分配的。动态数组写多了以后我会定期跑一遍 Valgrind防止realloc扩容过程中出现微小泄漏。还有一个感触很深的地方数组越界写很多时候不报错但它会在某个遥远的角落毁掉另一个变量。我调过一个线上问题某个模块的计算结果偶尔出错排查了几天最后发现是另一个模块的数组少写了一个边界条件越界覆盖了共享缓冲区。C 语言给了程序员最大的自由但也要求你必须自己守住边界。数组看着基础实际上是对“内存边界意识”最直接的训练。先把数组这一关过扎实后面学指针、学数据结构、学操作系统都会轻松很多。
查询的优化实战)
