企业官网建设流程全解析

C语言数组这个东西，太容易被人看轻了。我见过不少人，入门时觉得“不就是连续一段内存嘛，声明、下标、循环，三件套完事”，结果一上来自动判题系统，或者到了课程设计，就被字符串处理、指针混淆、二维数组内存排布、数组越界这些问题反复教做人。数组表面上语法简单，但它是C语言里承上启下的核心结构：承的是内存、指针这些底层概念，启的是链表、栈、队列、树这些后续数据结构。这篇文章我不想按教科书顺序讲，而是从我实际刷题、写课设、调bug的经历出发，把C语言数组从底层模型到初始化规则、从字符数组到指针数组、从经典算法到调试技巧完整拆一遍，顺便把PTA、翁恺课程里常考的题型和你可能踩的坑一起盘点掉。不管你是刚学C语言的大学生，还是准备期末复习、正在做课程设计的同学，相信都能从里面找到点能直接上手用的东西。

1. 从内存视角重新理解数组：为什么下标从0开始，数组名到底是什么

1.1 数组的本质是一块连续内存

数组在C语言里的定义，说穿了就是“同一类型元素的连续存放”。这句话听起来没信息量，但实际操作里大多数人其实没吃透“连续”这两个字。连续意味着两点：第一，所有元素在内存里是一块固定大小的区域，每一块内存大小完全一致；第二，元素与元素之间没有空隙，地址是紧挨着的。

打个比方，你可以把数组想象成一栋楼里的连续房间，每个房间门牌号递增，房间大小一样，里面只住同一种类型的数据。如果你知道第一个房间的门牌号（首元素地址）和每间房的大小（sizeof(类型)），就能推算出任意一间房的门牌号。这正是数组访问速度快的原因：不需要像链表那样一个节点一个节点地跳，直接算地址就行了。

所以定义数组的时候，C语言要求“元素类型”和“元素个数”至少要确定一个。类型确定每间房多大，个数确定总共有多少间房。有些初学同学喜欢这么写：

int arr[]; // 错误

这在C语言里是不合法的，因为编译器没法知道到底该分配多大空间。反过来说，如果给了初始化列表，编译器就能数出来你需要几个房间：

int arr[] = {10, 20, 30, 40}; // 等价于 int arr[4]

这也是数组定义里的一个高频考点，线上线下问我的人特别多。

1.2 下标为什么从0开始，而不是从1开始

这个问题几乎每次讲数组都会被问到。直接说结论：因为数组元素的地址计算公式是首地址 + 下标 * 元素大小，从0开始最自然，也最省指令。

如果下标从1开始，那么第1个元素的地址就得写成首地址 + (1 - 1) * 元素大小，每次访问都要多做一次减1运算，没有任何好处。从0开始，编译器可以直接用下标乘以元素大小再加上基地址，一步到位。底层硬件和编译器的设计都沿用了这个约定，所以你在几乎所有主流语言里看到的数组都是从0开始。

理解了这一点，你就知道为什么访问arr[i]等价于在地址base + i * sizeof(elem)处取数据。很多刚学指针的人看到这里容易绕进去，建议在纸上画一个格子图，把每个元素的内存地址写出来，比看十遍理论都管用。

另外提一句，Python的列表看着也像数组，但它里面存的是对象引用，不是一块连续的内存区域。Python里的“数组切片”语法在C语言里不存在，C语言要做类似的事，通常用一个指针指向起始位置，再配合一个长度来模拟子数组。这也是为什么你搜“数组切片”搜出来的多半是Python教程，但在C语言里几乎没人这么说。

1.3 数组名到底是地址常量，还是指针变量

这是C语言入门必考、“杀伤力”极大的一处概念。数组名在大多数表达式里会“退化”成指向首元素的指针，比如你把数组传给函数，本质上传的是首元素地址。但数组名本身并不是指针变量，它是地址常量，不能像指针那样随便被赋值指向别处。

验证方法很简单：

int arr[5]; printf("%zu\n", sizeof(arr)); // 20，整个数组的大小 int *p = arr; printf("%zu\n", sizeof(p)); // 8（64位系统），指针本身的大小

就凭这个输出，你就能看出数组名和指针不是同一个东西。但如果你把数组名直接传给一个函数，函数收到的只是地址，函数内再用sizeof拿到的是指针大小，不是数组大小。很多初学者在这个地方翻车，后面我会专门讲函数传参的坑。

和数组名相关的另一个常见概念是“指针数组”和“数组指针”。简单记一下：

• int *p[5]：指针数组，数组里每个元素是int *类型的指针；
• int (*p)[5]：数组指针，p指向一个含有5个int元素的整型数组。

这两个写法在有些题里很容易混，而你如果理解了“[]优先级高于*”这个规律，就不会记错：int *p[5]先看[]，所以这是一个数组；int (*p)[5]先看括号里的*，所以这是一个指针。

数组在现代系统编程里也有极强的存在感。比如select函数里的fd_set类型，本质上就是把文件描述符集合放在一个位数组里，用位来标记某个描述符是否就绪。很多刚接触网络编程的同学觉得FD_SET、FD_ISSET这些宏很神秘，拆开看底层就是数组位运算。C语言数组不是只在入门课本里出现的东西，它就是系统底层的基石。

2. 一维数组的声明、初始化与遍历：那些最容易踩的坑

2.1 声明形式和初始化规则，一次说清楚

C99之前，数组大小要求是编译期常量，所以你不能写int n; scanf("%d", &n); int a[n];这种代码。C99引入了变长数组（VLA），在支持这个特性的编译器上，可以按变量来定义数组长度。但要注意，VLA虽然用起来方便，它是在栈上分配空间的，如果n特别大，很容易栈溢出。我自己在课程设计里就遇到过这种问题，当时用VLA定义了一个几十万大小的数组，程序一跑就崩，后来改成动态内存分配才解决。

数组初始化规则里比较重要的是“部分初始化”。下面这段代码：

int arr[5] = {1, 2};

结果是什么？数组前两个元素是1和2，剩下的三个元素自动补0。这个特性在很多题目里能帮你省不少事，比如你想创建一个全零数组，直接写int arr[10] = {0};就行，第一项明确指定0，剩下的自动填0。另外还有C99引入的“指定初始化器”，可以指定某个下标：

int arr[10] = {[2] = 5, [5] = 8};

这种方式在稀疏初始化时很实用，考试题目偶尔也会出现，知道它存在就不会懵。

字符串数组也是非常常见的“数组初始化”场景。这里要特别区分两个东西：

char s1[] = "hello"; // 大小是6，含末尾的'\0' char s2[] = {'h','e','l','l','o'}; // 大小是5，没有'\0'

第二个写法不是一个C字符串，它只是字符数组，不能直接当作字符串用。你如果printf("%s", s2)，可能会一直读到内存里下一个碰巧出现的\0为止，这就是所谓的“未定义行为”。初学阶段字符串相关的错误，十有八九都是“少了结尾的空字符”引起的。

2.2 遍历、越界与“数组增加”这件事

遍历数组最常见的写法就是for (i = 0; i < n; i++)，注意边界是<不是<=。我见过太多人顺手写成i <= n，然后访问arr[n]，C语言编译阶段不报错，运行阶段大概率也不报错，但实际上那已经是数组之外的内存了，属于未定义行为。这也是C语言初学者最痛苦的体验：Java里越界直接抛异常，C语言里越界就是“死给你看，或者假装一切正常”。

数组大小是固定的，但很多人经常问“怎么给数组增加一个元素”。这个问题的答案是：C语言的数组不能直接增加。要么你手动写一个更大的新数组，把旧元素拷贝过去，要么用动态内存分配，借助realloc扩展内存。很多课设里要维护一个动态增长的数组，推荐直接这么做：

int *arr = malloc(10 * sizeof(int)); int capacity = 10, size = 0; // 当 size == capacity 时扩容 if (size == capacity) { capacity *= 2; arr = realloc(arr, capacity * sizeof(int)); }

这种“倍增扩容”的思路好处是平摊复杂度低，平均每次插入的代价是O(1)级别。对比一下VBA数组或者Python列表，你会发现它们的动态扩容本质上也是这个套路，只是底层帮你做了。

遍历过程中经常需要做的操作是“数组去重”。最简单的办法是先排序再遍历：排序可以让相同的元素靠在一起，遍历时跳过重复值。这里就自然过渡到后面的排序话题了。但如果你不想更改原数组顺序，也可以用一个辅助标记数组（布尔数组）来记录某个值是否出现过，空间换时间。

2.3 数组作为函数参数：传的不是数组，是首元素指针

把数组传给函数，是C语言为数不多“语法看着像值传递、实际是指针传递”的地方。你写：

void f(int a[]) { ... }

和写void f(int *a)是等价的。这也意味着函数内部并不知道数组有多少个元素，没有边界信息。所以正确的做法是，数组和长度一起传：

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

如果想防止函数内修改原数组内容，可以用const int a[]修饰参数。这相当于告诉编译器：你可以用下标访问，但不允许写。写代码时的好处是，如果你不小心在函数里写了a[i] = x，编译器直接报错，不会等到运行期出bug。

另一个容易被忽略的点是，在函数内部对数组参数做sizeof(a)得到的是指针大小，而不是数组大小。这个陷阱每年期末都会坑一批人。我自己的习惯是，凡是函数拿到数组参数，默认它就是指针，长度必须靠外部传入，这就是函数的“边界契约”。

3. 字符数组、字符串与指针数组：C语言里最绕的数组变体

3.1 字符数组和字符串的关系，差的就是一个'\0'

字符数组就是元素类型为char的数组。C语言规定，以空字符'\0'结尾的字符数组可以当作字符串处理，库函数如strlen、strcpy、printf("%s")都是靠扫描'\0'来判断字符串结束位置的。

这解释了很多常见现象，比如strlen统计长度时不包含末尾的'\0'，但sizeof会包含。再比如你写char name[10]然后往里存一个长度刚好等于10的字符串，就会因为没有位置放'\0'而出现一系列奇怪问题。所以给字符串预留空间时，永远要多留一个字节给'\0'。

库函数这块，C语言并没有像Java或Python那样自带一堆数组方法，字符串处理全靠<string.h>里的那批函数，包括strlen、strcpy、strcat、strcmp、strchr、strstr、strtok等。我会建议初学者把它们当“数组方法”来理解：你完全可以用手写循环实现同样的逻辑，但库函数通常更稳、更高效，而且已经过了大量测试。比如字符串复制，自己写循环难免漏掉'\0'的复制，用strcpy就很少出这种问题。

3.2 字符串逆序：PTA经典题的多角度拆解

PTA（拼题A）上有一道非常经典的字符串逆序题，具体要求是输入一个字符串，输出它的逆序字符串。题目看起来简单，但实现方式很能体现对字符数组的理解。

最直接的方式是双指针：

void reverseString(char s[]) { int left = 0, right = strlen(s) - 1; while (left < right) { char tmp = s[left]; s[left] = s[right]; s[right] = tmp; left++; right--; } }

这里有个细节：字符串末尾的'\0'不能被移动，否则字符串就“断开”了。所以交换范围只到strlen(s)-1的位置。理解了双指针，你再去写“字符串反转后输出”“判断回文串”这类题目就会顺手很多。

逆序还有一种更接近底层的方式是“倒序拷贝”到新数组，但空间复杂度高一些。PTA上如果你用这种思路，也OK，只要记得在新数组末尾补上'\0'。

3.3 指针数组存放字符串：到底存的是字符串还是地址

指针数组和字符数组结合，最常见的用法是：

char *colors[] = {"red", "green", "blue"};

这个数组里每个元素都是一个char *指针，分别指向一个字符串字面量。注意，字符串字面量存储在只读区，你如果尝试colors[0][0] = 'R'，在多数系统上会崩溃或触发未定义行为。所以如果你想修改字符串内容，最好用二维字符数组：

char colors[][10] = {"red", "green", "blue"};

这两种写法的区别一定要分清：指针数组节省空间、适合只读的字符串集合；二维字符数组合适需要修改内容的场景。做题的时候如果遇到“按要求输出几个字符串并且需要排序交换”，用二维字符数组或指针数组加单独的长度信息都可以，关键是别把只读字符串当普通数组去改。

和“数组转字符串”相关的场景，常见做法是把一个字符数组里的内容拼接成一个完整字符串。如果你有一组键值对或者从文件里读入若干行，需要拼成一个输出串，可以考虑用sprintf或snprintf逐段写入，也可以直接用strcat。但strcat有两个坑：目标缓冲区必须足够大，而且必须以'\0'开头（至少要有结束符），否则它会继续往后找结束位置，很容易越界。我推荐用snprintf，因为它可以传缓冲区大小，能在写入前确认不会溢出。

3.4 数组分割并显示包含某一字符

热搜里有“数组分割并显示包含某一字符”，这是一个比较典型的字符串数组处理需求。比如你有一个字符串"apple,banana,cherry,date"，想按逗号分割，然后筛选出包含"an"的部分。C语言里可以用strtok分割，然后用strstr判断是否包含：

char line[] = "apple,banana,cherry,date"; const char *sep = ","; char *tok = strtok(line, sep); while (tok != NULL) { if (strstr(tok, "an") != NULL) { printf("%s\n", tok); } tok = strtok(NULL, sep); }

这里有个很重要的注意事项：strtok会修改原字符串，把分隔符位置替换成'\0'。所以如果原数组后面还要用，就得先备份一份。另外strtok不是线程安全的，多线程环境下要考虑strtok_r。这个题目看起来很实用，但考的就是你对“字符串修改”和“指针遍历”两个点的掌握程度。

4. 二维数组与多维数组：矩阵类题目的命门

4.1 二维数组在内存里其实是“一维”的

二维数组int a[3][4]在内存里不是分成3行4列的一个“格子”，而是连续分配的12个int，按“行优先”顺序排列。也就是说，a[1][0]的地址紧跟在a[0][3]后面。

这个特性非常关键。它意味着：

• 你可以把二维数组当作一维数组来遍历，比如用指针从头扫到尾；
• 二维数组作为函数参数时，列数必须显式写出，因为编译器要靠列数计算地址偏移；
• a[i][j]等价于*(*(a+i)+j)，理解这个等价关系，指针与数组之间就不会乱。

多维数组相关的题里，最常见的是输出一个矩阵、计算对角线之和、转置、以及“鞍点”这类问题。鞍点问题的题面通常是：在一个矩阵中找到一个元素，它是所在行的最大值，同时是所在列的最小值，输出它的位置和值。5×5矩阵的鞍点题目是浙大PTA上的经典题，我给的思路是分两步做：先算每行的最大值，再算每列的最小值，最后判断是否有某个元素同时满足两个条件。这里用limits.h里的INT_MIN和INT_MAX作为临时最大最小值初始值，是个很实用的技巧。很多同学的代码出错，就是因为初始值设成了0，但矩阵里明明有负数。

九九乘法表也是二维数组或循环嵌套的经典输出题，虽然它实际上只需要两层循环而不需要数组存储，但很多老师会要求把结果存到二维数组里再输出，主要目的是练二维数组的下标操作。输出九九乘法表时要注意格式控制：%-2d左对齐两位，输出效果才会整齐。

4.2 二维数组和“不同class可以组成数组吗”这类跨语言问题

热搜里有“c# 不同的class可以组成数组吗”，这类问题本质上是想确认“数组元素能否是任意类型”。答案是可以，前提是这些不同的class有一个共同的基类型。C#里可以用基类数组或接口数组来装不同类的对象，比如Shape[] shapes = new Shape[3]，里面放Circle、Rectangle这些子类对象。这依赖的是面向对象的继承和多态。

但在C语言里没有class，也没有继承、多态。如果你需要“不同类型的元素组在一起”，通常有两个替代方案：一是用结构体数组，把不同类型的数据包在一个结构体里；二是用指针数组，让不同函数指针或不同类型对象的地址放在一个数组里，然后按需类型转换。C语言更贴近底层，数组里放什么类型完全由你来定，编译器不会替你处理“共性”，所以更考设计能力。

顺便提一句VBA数组：VBA里的Variant数组可以装不同类型，性能上通常不如类型固定的数组。C语言数组没有这种运行时类型信息，反而给了你最大的性能掌控力。很多人问Cython是不是比单纯C语言更高效，我的理解是，Cython的目的其实是让Python代码跑得更快，它底层最终还是要调用C编译产物，真要追求极致效率，直接用C实现核心逻辑通常不会比Cython慢。C语言数组的高效，恰恰来自这种“零抽象、零装箱”的直接内存操作。

4.3 矩阵转置与“多维数组指针”进阶

多维数组最常见的高级玩法是多维数组指针作为函数参数。假设你写一个函数处理一个3x4矩阵：

void process(int a[][4], int rows) { // 这里必须写出列数4 }

也可以写成void process(int (*a)[4], int rows)。这两种写法在编译层面一模一样。如果参数里不写列数，编译器没法计算a[i][j]的真实地址，所以不会编译通过。

转置矩阵的题目里，最值得注意的点是不能直接“原地”交换a[i][j]和a[j][i]，除非矩阵是方阵。非方阵转置后行列数会变化，目标数组大小和源数组不同，必须新开数组。类似这种题目做过几道后，你对二维数组“行优先存储”的感觉就会建立起来。

5. 数组与经典算法组合实战

5.1 冒泡排序：双重循环背后藏着优化空间

冒泡排序是最经典的数组入门算法，它的思路是反复交换相邻的逆序元素，每趟让一个最大值“冒”到末尾。标准写法：

void bubbleSort(int a[], int n) { for (int i = 0; i < n - 1; i++) { int swapped = 0; for (int j = 0; j < n - 1 - i; j++) { if (a[j] > a[j + 1]) { int tmp = a[j]; a[j] = a[j + 1]; a[j + 1] = tmp; swapped = 1; } } if (!swapped) { break; } } }

中间那个swapped标志就是优化点：如果某一趟没有任何交换，说明数组已经有序，可以提前结束，避免做无用功。这个小优化在数据基本有序的情况下能把复杂度从O(n²)降到接近O(n)。别小看这几行代码，面试或考试时，很多同学背得住外层循环内层循环，却漏了提前结束的判断。数组的排序是后续很多算法的基础，比如前面提到的数组去重，就是先排序再去重。

5.2 一列数里哪些数据和等于固定值

热搜里有“一列数，已知固定数值，如何确定数组中的哪些数据和等于固定值”，这是一个经典的“子集求和”问题。最简单也最好理解的做法是回溯：从第一个元素开始，决定“选它”或“不选它”，每次选完更新当前和，和目标值比较。

void findSubsets(int a[], int n, int target, int index, int sum, int chosen[]) { if (sum == target) { // 输出当前组合 } if (index == n || sum > target) { return; } chosen[index] = 1; findSubsets(a, n, target, index + 1, sum + a[index], chosen); chosen[index] = 0; findSubsets(a, n, target, index + 1, sum, chosen); }

这个问题的完整实现比冒泡排序复杂一些，但它对理解“递归遍历数组的所有子集”非常有帮助。如果数据中有重复数字、且要求不使用同一元素超过一次，还要再加去重剪枝。实际做题时如果数组很大（比如超过20个元素），回溯的指数级复杂度过高，就得考虑动态规划或 meet-in-the-middle 的思路了。

5.3 循环队列：q[m]、rear 与 length 的组合

热词里有一道非常典型的数据结构题：假设以数组q[m]存放循环队列的元素，同时以rear和length分别指示环形队列中队尾元素的位置和队列所含元素个数，要求写入队出队算法。这个题的巧妙之处在于，不用front用length，可以避免“队空与队满无法区分”的经典问题。

队空判断是length == 0，队满判断是length == m。入队时：

q[rear] = x; rear = (rear + 1) % m; length++;

出队时：

front = (rear - length + m) % m; x = q[front]; length--;

这里的取模运算就是循环数组的灵魂。很多同学第一次看到% m不理解，其实就是“转圈”：数组下标到达 m-1 后下一个回到 0。循环数组在操作系统、网络缓冲区的使用非常频繁，理解了取模，你就理解了一切环形缓冲区的工作原理。

5.4 树状数组初探：sum(11) 和 add(3, x) 的底层逻辑

树状数组（Fenwick Tree）是算法竞赛里非常实用的数据结构，它能用数组高效维护前缀和，支持单点修改和区间查询。原理是利用二进制下标的 lowbit 进行跳跃。比如n = 16的序列，查询前缀和sum(11)时，11的二进制是1011，lowbit(11)=1，先加上tree[11]，再跳到 10（1010），加上tree[10]，再跳到 8（1000），加上tree[8]，跳到 0 结束。所以sum(11)等于tree[11] + tree[10] + tree[8]。

单点修改add(3, x)时，3的二进制是0011，lowbit(3)=1，先更新tree[3]，跳到 4，更新tree[4]，跳到 8，更新tree[8]，跳到 16，更新tree[16]，结束。所以一次更新要改4个节点。核心代码只有几行：

int lowbit(int x) { return x & -x; } int sum(int i) { int res = 0; for (; i > 0; i -= lowbit(i)) res += tree[i]; return res; } void add(int i, int delta) { for (; i <= n; i += lowbit(i)) tree[i] += delta; }

这段代码的妙处在于：它把一个看似需要循环求和的问题，转换成了数组在二进制下标上的跳跃查询。学到这里你会更深刻地理解，C语言数组不只是“存数据”的地方，它还能成为算法结构的载体。很多人觉得树状数组难，其实就是没搞清楚 lowbit 那几步下标变化。你在草稿纸上画一个下标1到16的树状图，把sum(11)和add(3,x)的路径标出来，比死记代码有用得多。

6. 调试、环境配置与数组常见错误速查

6.1 vscode和虚拟机（Ubuntu）里的C语言调试环境

写数组相关的代码，最怕的不是不会语法，而是程序“莫名其妙就崩了”。这时候一个趁手的环境和调试工具很重要。目前大学生用得比较多的组合是VS Code + GCC + GDB，如果你用虚拟机装的是Ubuntu，一般自带或通过一条命令就能装上GCC：

sudo apt update sudo apt install gcc gdb build-essential

VS Code配置C语言环境的核心是安装C/C++扩展，再配置tasks.json和launch.json，分别负责编译和调试。很多人卡在中文路径或文件名空格上导致编译失败，我的建议是把代码路径统一改成纯英文、无空格。这一步看起来无关紧要，但能省掉大量玄学问题。

GDB调试数组时，我常用的几个命令是：

• print arr[0]@10：从arr[0]开始连续打印10个元素；
• x/10dw arr：以十进制形式查看从arr地址开始的10个字；
• watch arr[i]：监控某个下标的值变化。

特别是print arr[0]@10这种“连续内存”打印方式，能让你一眼看出哪里越界修改了不该动的内存。很多数组越界bug在逻辑上很难看出来，但用GDB一看内存分布就懂了。

6.2 数组常见错误速查表

这一节给我平时被问得最多、以及我自己上课和带新同学时常遇到的问题做一个速查表：

其中“大数组导致栈溢出”最常见于课程设计里，比如模拟虚拟存储器管理，需要很大的页表数组。局部变量默认分配在栈上，栈空间一般只有几MB，你放一个int a[1000000]很可能直接爆栈。解决办法是把大数组放到全局区，或者用malloc放到堆上。C语言里“数组初始化和定义”位置的选择，直接影响程序能不能跑起来，这个地方也值得注意。

6.3 学习路线与资源：翁恺、PTA、PAT与一个小练习项目

如果你是C语言新手，我建议的路线是：先把翁恺的《零基础学C语言》网课里数组相关章节看完，跟着敲一遍代码；然后去浙大的PTA平台刷数组和字符串相关的题；刷题遇到瓶颈时，再回头查C语言库函数大全和具体语法细节，而不是一头扎进抄代码的循环里。

PTA上有不少适合练数组的题，比如字符串逆序、鞍点问题、矩阵转置、九九乘法表。PAT（乙级）里也有大量基于数组的模拟题，像1037“在霍格沃茨找零钱”就是把货币单位拆成三个数组分量去计算，考察仔细读题和数组/结构体处理能力。做这种题的好处是，题目要求你必须把边界看死，任何一个下标越界都可能导致判题系统返回运行时错误。

还有一个我特别推荐的练手项目：C语言打字游戏。它的小程序逻辑很简单，随机生成字符，玩家输入逐个匹配，但这背后涉及字符数组的存储、长度计算、循环刷新，甚至可以用二维数组做排行榜。如果学校要求C语言课程设计，这个题目难度适中，又和数组密不可分。再往上一点，你就试着用数组模拟“虚拟存储器管理”，把页表、位示图、地址流都放进数组里，做一个简单的页面置换演示程序，做完之后你对数组的理解会上一个台阶。

最后分享一个我在实际调试中养成的习惯：写数组代码之前，永远先问自己三个问题——数组大小是多少、元素类型占几个字节、循环边界到底取到几。如果这三个答案你都清楚，那数组相关的大多数问题根本不会发生。数组是你和内存之间最直接的一层抽象，把它理解透了，后面学指针、链表、树，都会顺畅很多。