C++一维数组深度解析：从内存模型到现代容器实践

1. 项目概述：为什么一维数组是C++的基石

如果你刚开始学C++，或者已经写过一些代码，那么“数组”这个概念你一定不陌生。但你真的理解它吗？我见过太多新手，甚至一些工作一两年的朋友，对数组的理解还停留在“一个能存一堆数的地方”这个层面。当遇到指针、内存越界、动态分配这些概念时，就彻底懵了。今天，我想从一个写了十几年C++的老码农的角度，跟你彻底聊透“一维数组”这个东西。它远不止是语法书上的几行定义，而是理解C++内存模型、指针、乃至现代C++容器（如vector）的绝佳入口。

简单说，一维数组就是一段连续的、固定大小的、存储相同类型数据的内存块。这个“连续”和“固定大小”是它的核心特征，也是它所有优点和缺点的根源。从存储游戏里一排敌人的坐标，到处理传感器传来的一串数据，再到作为更复杂数据结构（如哈希表、堆）的基础，数组无处不在。理解它，你才能理解为什么vector的push_back操作有时会“慢”，为什么有些算法要求数据在内存中连续存放，以及那些令人头疼的“段错误”到底从何而来。

这篇文章，我会带你从最基础的声明、初始化开始，一步步深入到它在内存中的真实样貌、与指针那剪不断理还乱的关系、作为函数参数传递时的“坑”，最后再聊聊在现代C++中，我们如何看待和使用这个“古老”的数据结构。我的目标是，看完之后，你能对数组建立起一个立体的、透彻的认知，而不仅仅是记住语法。

2. 一维数组的核心概念与内存模型

2.1 声明与初始化：语法细节里的魔鬼

声明一个数组的语法看起来很简单：type name[size];。比如int scores[10];就声明了一个能存放10个整数的数组。但这里有几个新手极易踩坑的细节。

首先，这个size，也就是数组的大小，在标准C++中（C++11之前），必须是一个编译期常量表达式。这意味着它必须是在编译阶段就能确定的值。数字字面量（如10）、用const修饰的整型变量（如const int N = 10;）、或者枚举值，这些都是可以的。但普通的变量不行。

// 正确示例 int arr1[5]; // 字面量 const int SIZE = 20; int arr2[SIZE]; // const常量 #define COUNT 100 // 宏定义（虽然不推荐，但可行） int arr3[COUNT]; // 错误示例 int n = 50; int arr4[n]; // 错误！n是非常量变量。在大多数编译器下，这属于“变长数组”(VLA)，是C99的特性，并非标准C++。

注意：虽然GCC等编译器在C++模式下可能支持变长数组作为扩展，但为了代码的可移植性和符合标准，请绝对不要依赖这个特性。如果你需要一个运行时决定大小的“数组”，你应该使用std::vector。

初始化数组也有多种方式：

// 1. 全零初始化（对于内置类型） int arr1[5] = {}; // 所有元素为0 int arr2[5] = {0}; // 同上，第一个元素显式设为0，其余自动补0 // 2. 列表初始化（C++11及以后推荐） int arr3[] = {1, 2, 3, 4, 5}; // 编译器自动推导大小为5 int arr4[5] = {1, 2}; // 前两个元素为1,2，后三个自动初始化为0 // 3. 字符数组的特殊性 char str1[] = {'H', 'e', 'l', 'l', 'o'}; // 大小为5，没有终止符，这不是C风格字符串！ char str2[] = {'H', 'e', 'l', 'l', 'o', '\0'}; // 大小为6，是C风格字符串 char str3[] = "Hello"; // 最常用！编译器会自动在末尾添加'\0'，所以str3的大小是6。 // char str4[5] = "Hello"; // 错误！没有空间存放自动添加的'\0'

这里有一个非常重要的实操心得：对于内置类型（如int,double,char*）的数组，如果你不进行任何初始化，那么数组元素的值是未定义的（垃圾值）。这会导致程序行为不可预测，是很多诡异Bug的源头。养成声明时即初始化的好习惯，比如int arr[100] = {};，可以避免大量问题。

2.2 内存布局：连续性是性能的关键

数组的所有元素在内存中是连续存储的。这是数组最重要的特性，没有之一。假设我们声明了int arr[5] = {10, 20, 30, 40, 50};，它在内存中的布局大致是这样的：

注意，int类型通常占4个字节，所以每个元素的地址相差4。这种连续性带来了巨大的优势：

1. 缓存友好：当CPU读取arr[0]时，很可能将后面连续的一大块内存（一个缓存行，通常是64字节）一起加载到高速缓存中。接下来访问arr[1],arr[2]时，速度会极快。这是数组遍历效率高的根本原因。
2. 指针运算的基石：因为地址是连续的，所以我们可以通过基地址加上偏移量来直接计算任何元素的地址。这也就是arr[i]在底层被等价为*(arr + i)的原因。

理解这个内存模型，你就能明白为什么“数组下标从0开始”。因为第一个元素的地址就是数组的起始地址（基地址），偏移量i代表“跳过i个元素”。arr[0]的地址是arr + 0，arr[1]的地址是arr + 1*sizeof(int)，依此类推。从0开始是最自然、最符合底层逻辑的设计。

2.3 数组名与指针：那个著名的“退化”规则

这是C/C++中最让人困惑的关系之一。你需要记住一个核心规则：在大多数表达式中，数组名会“退化”为一个指向其首元素的常量指针。

这句话有两个关键点：

1. “退化”：数组名本身并不是一个指针变量，它代表的是整个数组对象。但在需要指针值的上下文中（比如赋值给指针、作为函数参数），它会自动转换成指针。
2. “常量指针”：这个转换得到的指针值（指向首元素）是固定的，你不能修改这个指针本身让它指向别处。arr = somethingElse;这样的操作是非法的。

看看这些例子：

int arr[5] = {1, 2, 3, 4, 5}; // 示例1：数组名退化为指针 int* ptr = arr; // 正确。arr退化为&arr[0]，类型是int* cout << *ptr; // 输出 1 // 示例2：对数组名取地址 int (*ptr_to_array)[5] = &arr; // 正确。这是“指向整个数组的指针”，类型是int(*)[5] // ptr_to_array + 1 会跳过整个数组（5*4=20字节） // 示例3：sizeof 操作符是例外 cout << sizeof(arr); // 输出 20 (5 * 4)。这里arr代表整个数组对象，没有退化。 cout << sizeof(ptr); // 输出 8 (64位系统下指针的大小)。ptr只是一个指针。 // 示例4：数组名不能作为左值 // arr = ptr; // 错误！arr不是可修改的左值。

这个“退化”规则直接导致了C++中一个经典且容易出错的问题：数组作为函数参数传递时，会退化为指针。我们稍后会详细讨论。

3. 数组的访问、遍历与边界问题

3.1 访问元素与越界访问：沉默的杀手

访问数组元素很简单，使用下标运算符[]即可：arr[index]。但这里隐藏着C++（以及C）最危险的一个特性：不进行边界检查。

编译器不会阻止你写arr[10]，即使你的数组大小只有5。它会忠实地计算arr + 10这个地址，然后去读写那块内存。那块内存可能属于其他变量、函数调用栈、甚至是不可访问的区域。这会导致：

• 数据损坏：你修改了其他变量的值。
• 程序崩溃：你访问了受保护的内存，触发“段错误”(Segmentation Fault)。
• 安全漏洞：这是很多缓冲区溢出攻击的原理。

int arr[5] = {0}; arr[5] = 42; // 越界写入！行为未定义。可能悄无声息地破坏数据，也可能立即崩溃。 int x = arr[-1]; // 越界读取！同样是未定义行为。

实操心得：对付数组越界，没有银弹。但你可以养成以下习惯来防御：

1. 使用有意义的常量作为大小：const int MAX_STUDENTS = 100; int scores[MAX_STUDENTS];。这样大小更清晰。
2. 循环时严格检查索引：for(int i = 0; i < MAX_STUDENTS; ++i)。确保循环变量i的终值严格小于数组大小。
3. 考虑使用std::array(C++11)：它提供了at()成员函数，会在运行时进行边界检查（如果越界会抛出std::out_of_range异常），虽然牺牲一点性能，但在调试阶段非常有用。
4. 使用范围for循环 (C++11)：for(int val : arr) { ... }。这能自动处理边界，但前提是你知道arr的确定范围（对于传入函数的数组指针则不行）。

3.2 遍历数组的多种方式及其优劣

遍历是数组最常用的操作。我们来对比几种常见方式：

1. 传统for循环

for (int i = 0; i < 5; ++i) { cout << arr[i] << " "; }

• 优点：最灵活，可以访问索引i，可以反向遍历，可以跳着遍历。
• 缺点：需要手动控制边界，容易出错。

2. 基于范围的for循环 (C++11)

for (int element : arr) { cout << element << " "; } // 使用auto更简洁 for (auto& element : arr) { // 使用引用避免拷贝，特别是元素类型较大时 element *= 2; // 可以修改元素 }

• 优点：语法简洁，绝对安全，不会越界。是遍历容器（包括数组、vector、list等）的首选。
• 缺点：无法直接获取当前元素的索引。如果需要索引，仍需用传统for循环。

3. 使用指针遍历

for (int* p = arr; p != arr + 5; ++p) { cout << *p << " "; }

• 优点：更接近底层，有时在特定算法或与C接口交互时有用。
• 缺点：可读性较差，更容易出错（比如错误的终止条件）。

4. 使用标准库算法

#include <algorithm> #include <iostream> #include <iterator> std::copy(std::begin(arr), std::end(arr), std::ostream_iterator<int>(std::cout, " "));

• 优点：函数式风格，通常更安全，意图明确。
• 缺点：语法稍复杂，对于简单遍历有点“杀鸡用牛刀”。

对于新手，我强烈推荐先掌握传统for循环和范围for循环。前者让你理解底层机制，后者让你写出更安全、更现代的代码。

3.3 一维数组的经典练习题解析

让我们用一道经典的练习题来巩固一下：“给定一个包含 n 个整数的一维数组，请将相邻的两个元素进行交换。即第1个和第2个交换，第3个和第4个交换，以此类推。”

这道题考察了数组访问、循环控制和边界条件处理。我们来一步步拆解：

#include <iostream> using namespace std; void swapAdjacent(int arr[], int n) { // 关键点1：循环的步长是2，因为我们每次处理一对元素 for (int i = 0; i < n - 1; i += 2) { // 关键点2：使用临时变量交换两个相邻元素 int temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } } int main() { int arr[] = {1, 2, 3, 4, 5, 6}; int n = sizeof(arr) / sizeof(arr[0]); // 计算数组长度 cout << "原始数组: "; for (int i = 0; i < n; ++i) cout << arr[i] << " "; cout << endl; swapAdjacent(arr, n); cout << "交换后数组: "; for (int i = 0; i < n; ++i) cout << arr[i] << " "; cout << endl; return 0; } // 输出： // 原始数组: 1 2 3 4 5 6 // 交换后数组: 2 1 4 3 6 5

核心要点与避坑指南：

1. 循环条件i < n - 1：这是为了防止越界。当i指向最后一个元素（奇数个元素时）或倒数第二个元素（偶数个元素时），i+1必须有效。i < n - 1确保了i+1最大为n-1，即最后一个元素的索引。
2. 步长i += 2：每次循环处理完一对元素（i和i+1），所以下一次应该跳到i+2。
3. 处理奇数长度数组：如果数组长度n是奇数，最后一个元素将没有配对的元素与之交换，它会保持原位。上述代码逻辑已经正确处理了这种情况。
4. 计算数组长度：sizeof(arr) / sizeof(arr[0])是获取内置数组长度的经典方法。但请注意，这只在数组定义的作用域内有效。一旦数组被传递给函数（退化为指针），sizeof(arr)得到的就是指针的大小，而不是数组的总大小。这就是为什么在swapAdjacent函数中，我们需要额外传递一个n参数。

这道题虽然简单，但它完美地串联了数组索引、循环边界和元素操作，是检验你是否真正理解数组基础的好题目。

4. 数组作为函数参数：退化的陷阱与应对

这是实际开发中最容易出问题的地方之一。我们直接看代码：

#include <iostream> using namespace std; // 方式1：指针形式 (最传统) void printArray1(int* arr, int size) { for(int i = 0; i < size; ++i) { cout << arr[i] << " "; // 仍然可以使用下标，因为arr是指针 } cout << endl; } // 方式2：数组形式 (本质上还是指针) void printArray2(int arr[], int size) { // 在函数内部，arr已经退化为指针 // sizeof(arr) 在这里是8（指针大小），而不是数组总大小！ for(int i = 0; i < size; ++i) { cout << arr[i] << " "; } cout << endl; } // 方式3：数组引用形式 (C++特有，可以保留数组大小信息) template <size_t N> void printArray3(int (&arr)[N]) { // 注意语法：(&arr) 表示arr的引用，[N]是类型的一部分 // 在这里，N是编译期常量，表示数组大小 // sizeof(arr) 能得到正确的数组总大小 for(int i = 0; i < N; ++i) { cout << arr[i] << " "; } cout << " (数组大小: " << N << ")" << endl; } int main() { int myArr[] = {10, 20, 30, 40, 50}; // 调用方式1和2，必须显式传递大小 printArray1(myArr, 5); printArray2(myArr, 5); // 调用方式3，大小自动推导！ printArray3(myArr); // 模板会自动推导出N=5 // 错误示例：试图在函数内计算传入数组的大小 // void badFunction(int arr[]) { // int wrongSize = sizeof(arr)/sizeof(arr[0]); // 错误！arr是指针，结果是8/4=2（64位系统） // } }

关键点解析：

• printArray1和printArray2是等价的。编译器看到int arr[]作为参数时，会立刻将其调整为int* arr。所以在这两个函数内部，你都无法通过sizeof获取数组的真实长度。必须额外传递一个大小参数，这是C风格的通用做法。
• printArray3使用了模板和数组引用。int (&arr)[N]是一个对数组的引用，它不会退化为指针，因此类型信息（包括大小N）得以保留。模板参数N会被自动推导。这是C++中更安全、更现代的方式，但它只适用于大小在编译期已知的数组。

避坑指南：如果你在函数内部需要对数组进行操作，并且需要知道其大小，优先考虑以下方案：

1. 使用std::array（固定大小）或std::vector（动态大小），它们自带size()成员函数。
2. 如果必须用内置数组，考虑使用数组引用+模板的方式（如printArray3）。
3. 如果以上都不行，老实地传递一个额外的大小参数。这是最通用但也最容易出错的方式，务必确保传入的大小是正确的。

5. 动态数组：new[]与delete[]的正确姿势

内置数组的大小必须在编译期确定。如果你需要在运行时根据用户输入、文件内容等来决定数组大小，就需要用到动态内存分配，也就是“动态数组”。

5.1 创建与销毁

动态数组通过new[]运算符创建，通过delete[]运算符释放。

int main() { int size; cout << "请输入数组大小: "; cin >> size; // 1. 动态分配 int* dynamicArray = new int[size]; // 在堆(heap)上分配 size * sizeof(int) 字节的内存 // 2. 初始化（可选，但建议做） for (int i = 0; i < size; ++i) { dynamicArray[i] = 0; // 或 cin >> dynamicArray[i]; } // 3. 使用... dynamicArray[0] = 100; // 4. 必须手动释放！ delete[] dynamicArray; // 使用 delete[] 而不是 delete dynamicArray = nullptr; // 好习惯：释放后将指针置空，防止“悬空指针” return 0; }

必须严格遵守的规则：

• new[]必须配对delete[]：用new[]分配，就必须用delete[]释放。如果用delete（没有方括号）来释放数组，行为是未定义的，通常会导致内存泄漏或程序崩溃。
• 释放后置空：释放内存后，立即将指针设置为nullptr。这可以防止后续误用已释放的内存（“悬空指针”）。
• 避免重复释放：对同一个指针调用delete[]两次是严重的错误。

5.2 动态数组的“长度”问题

动态数组只是一个指向堆内存的指针。系统不会为你记录它分配了多少内存。sizeof(dynamicArray)得到的永远是指针本身的大小（4或8字节）。你必须自己记住数组的长度！这是动态数组最大的管理负担，也是导致内存错误（越界、泄漏）的常见原因。

int* arr = new int[100]; // 没有任何内置方法可以获取100这个值 // 你必须自己维护一个变量，比如 int arrSize = 100;

正因为这个管理负担，在现代C++中，除非有极特殊的性能要求或兼容性限制，否则强烈建议使用std::vector来代替动态数组。vector在堆上管理动态数组，但自动处理了内存分配、释放、记录大小和容量，并且提供了丰富的成员函数（push_back,size(),resize()等），安全性和易用性远超裸指针。

6. 现代C++中的数组：std::array与std::vector

C++标准库提供了两个强大的工具来替代内置数组，它们更安全、功能更强大。

6.1std::array：固定大小数组的现代化身

std::array是C++11引入的模板类，位于<array>头文件中。它是对内置固定大小数组的封装，提供了STL容器的接口，同时保持了与内置数组相同的性能和内存布局（栈上分配）。

#include <iostream> #include <array> #include <algorithm> // for std::sort int main() { // 声明并初始化一个包含5个int的array std::array<int, 5> arr = {5, 3, 1, 4, 2}; // 1. 安全的访问 std::cout << "第一个元素: " << arr[0] << std::endl; // 不检查边界，快 std::cout << "最后一个元素: " << arr.at(4) << std::endl; // 检查边界，越界抛异常，安全 // 2. 自带大小信息 std::cout << "数组大小: " << arr.size() << std::endl; // 输出 5 // 3. 迭代器支持，可用于STL算法 std::sort(arr.begin(), arr.end()); // 排序 // 4. 范围for循环支持 for (const auto& num : arr) { std::cout << num << " "; } std::cout << std::endl; // 5. 不会退化为指针！作为函数参数能保留大小信息。 printStdArray(arr); // 可以按值或按引用传递 return 0; } // 函数接收std::array，大小是类型的一部分 void printStdArray(const std::array<int, 5>& arr) { // 在这里，arr.size() 是有效的 }

std::array的核心优势：

• 安全性：提供at()方法进行边界检查。
• 便利性：自带size()、front()、back()、empty()等方法。
• 兼容性：数据存储在连续内存中，可以通过arr.data()获取底层指针，与需要指针的C风格API交互。
• 作为函数参数：不会退化为指针，可以按值或按引用传递，类型信息完整。

何时使用std::array：当你需要一个编译期大小固定的数组时，应优先选择std::array而不是内置数组。它几乎没有性能损失，却带来了巨大的安全性和便利性提升。

6.2std::vector：动态数组的终极解决方案

std::vector是C++中最常用、最通用的动态数组容器，位于<vector>头文件中。它在堆上管理一个动态增长的数组。

#include <iostream> #include <vector> int main() { // 1. 创建 std::vector<int> vec; // 空vector std::vector<int> vec2(10); // 10个元素，默认初始化为0 std::vector<int> vec3 = {1, 2, 3, 4, 5}; // 列表初始化 // 2. 动态添加元素 for (int i = 0; i < 10; ++i) { vec.push_back(i * i); // 在末尾添加元素，vector会自动管理内存 } // 3. 访问元素（与array类似） std::cout << "第一个: " << vec.front() << ", 最后一个: " << vec.back() << std::endl; std::cout << "下标访问: " << vec[5] << std::endl; // 不检查边界 std::cout << "安全访问: " << vec.at(5) << std::endl; // 检查边界 // 4. 容量与大小 std::cout << "元素数量(size): " << vec.size() << std::endl; std::cout << "已分配容量(capacity): " << vec.capacity() << std::endl; // >= size vec.shrink_to_fit(); // 请求减少capacity以匹配size（不保证） // 5. 内存连续性保证 int* p = vec.data(); // 获取底层数组指针 // p指向的内存是连续的，可以传递给需要指针的C函数 // 6. 预先分配空间以避免多次重分配（性能优化） std::vector<int> largeVec; largeVec.reserve(10000); // 预先分配至少10000个元素的空间 for (int i = 0; i < 10000; ++i) { largeVec.push_back(i); // 在reserve的范围内，push_back不会引起重分配，效率高 } return 0; }

std::vector的核心优势与内部机制：

• 自动内存管理：你只管push_back，vector负责在背后分配更大的内存、拷贝原有元素、释放旧内存。这个“重分配”过程对用户是透明的，但有其成本。
• 连续存储：与内置数组一样，vector的元素在内存中是连续的，保证了缓存友好性和兼容性。
• 动态大小：size()返回当前元素数量，capacity()返回已分配的内存能容纳的元素数量。当size() == capacity()时，再添加元素就会触发重分配，capacity通常会按一定比例（如2倍）增长。
• reserve()的妙用：如果你事先知道大概要存多少元素，先用reserve()预分配空间，可以避免插入过程中多次重分配，大幅提升性能。

vector与内置动态数组的对比：

结论：对于几乎所有需要动态数组的场景，std::vector都是比裸指针动态数组更好的选择。它用微乎其微的性能代价，换来了巨大的安全性和开发效率提升。只有在极端性能敏感、或与某些特定底层API交互必须使用裸指针时，才考虑使用new[]/delete[]。

7. 常见问题、陷阱与调试技巧实录

即使理解了原理，在实际编码中还是会遇到各种问题。这里我总结了一些最常见的“坑”和解决方法。

7.1 数组长度计算失效

问题：在函数内部使用sizeof(arr)/sizeof(arr[0])计算数组长度，结果错误。

void processArray(int arr[]) { int size = sizeof(arr) / sizeof(arr[0]); // 大坑！arr是指针，不是数组 // 在64位系统，sizeof(arr)是8，sizeof(arr[0])是4，size=2，完全错误！ }

解决：

1. 对于内置数组，在函数外部计算好长度，作为参数传入。
2. 使用std::array，它自带size()。
3. 使用std::vector，它自带size()。
4. 使用模板+数组引用的方式传递数组（如前文printArray3）。

7.2 越界访问导致的数据损坏或崩溃

问题：循环条件写错，或者访问了负数索引、超出size-1的索引。

int arr[5]; for(int i = 0; i <= 5; i++) { // 错误！i最大应该是4，这里会访问arr[5] arr[i] = i; }

调试与预防：

1. 使用调试器：在IDE（如VS Code, CLion, Visual Studio）中设置断点，观察数组索引i的值和数组内容。
2. 使用assert：在关键位置插入断言。

   #include <cassert> int index = getSomeIndex(); assert(index >= 0 && index < arraySize); // 如果条件为假，程序会中止并报错 arr[index] = value;

3. 启用编译器 sanitizer：现代编译器（如GCC/Clang的-fsanitize=address，MSVC的AddressSanitizer）可以在运行时检测越界访问，并给出详细的错误报告。这是非常强大的工具。
4. 使用安全容器：在调试阶段，可以暂时使用std::vector的at()方法或std::array的at()方法，它们会抛出异常，帮助你快速定位问题。

7.3 动态内存管理错误

问题1：内存泄漏。分配了内存（new[]）却忘记释放（delete[]）。

void leakyFunction() { int* p = new int[1000]; // ... 使用p ... // 忘记 delete[] p; // 内存泄漏！ }

解决：养成“谁分配，谁释放”的思维。使用RAII（资源获取即初始化）原则，让对象生命周期管理资源。最简单的方法就是直接用std::vector。

问题2：重复释放。对同一个指针调用delete[]多次。

int* p = new int[10]; delete[] p; // ... 很多行代码之后 ... delete[] p; // 灾难！p指向的内存可能已被重新分配

解决：释放后立即将指针置为nullptr。delete[]一个nullptr是安全的（什么也不做）。

delete[] p; p = nullptr; // 好习惯 // 即使后面不小心再 delete[] p，也是安全的

问题3：使用已释放的内存（悬空指针）。

int* p = new int[10]; delete[] p; p[0] = 5; // 未定义行为！p是“悬空指针”

解决：同样是释放后置空。并在代码逻辑上避免在释放后继续使用指针。

7.4 多维数组与一维数组的模拟

严格来说，C++只有一维数组。所谓的“二维数组”实际上是“数组的数组”。

int matrix[3][4]; // 一个包含3个元素的数组，每个元素又是一个包含4个int的数组

它在内存中仍然是连续存储的，按“行优先”排列。但操作起来语法稍复杂，且作为函数参数传递时退化规则更让人头疼。

很多时候，我们用一个一维数组来模拟二维数组，反而更简单、更高效。

int rows = 3, cols = 4; int* matrix = new int[rows * cols]; // 分配一块连续内存 // 访问第i行第j列的元素 // 索引公式：i * cols + j int getElement(int* mat, int i, int j, int cols) { return mat[i * cols + j]; } void setElement(int* mat, int i, int j, int cols, int value) { mat[i * cols + j] = value; } // 使用 setElement(matrix, 1, 2, cols, 42); // 设置第1行第2列（0-based）为42

优点：

• 内存完全连续，缓存局部性更好。
• 动态分配简单（一次new[]）。
• 作为函数参数传递方便（一个指针加行列数即可）。

缺点：需要手动计算索引，容易出错。对于这种情况，使用std::vector<std::vector<int>>或专门的多维数组库（如Eigen）可能是更好的选择，除非你非常追求性能。

8. 从数组到算法：理解数据结构的起点

数组的简单性使其成为学习更复杂数据结构和算法的完美起点。几乎所有的基础算法教学都从数组操作开始。

排序：冒泡排序、选择排序、插入排序、快速排序、归并排序，这些算法的核心都是在数组上比较和交换元素。理解数组的随机访问特性（O(1)时间复杂度），你才能理解为什么快速排序比链表上的排序快。

搜索：线性查找就是遍历数组。二分查找则依赖于数组的有序性和随机访问特性，它要求能在常数时间内跳到中间位置，这是链表无法提供的。

作为其他结构的基础：

• 栈和队列：可以用数组轻松实现（维护一个头/尾指针）。
• 堆（优先队列）：二叉堆通常就用数组来存储，利用下标关系来表示父子节点。
• 哈希表：开链法解决冲突时，每个桶可能就是一个链表或动态数组；开放寻址法则直接在一个大数组上进行操作。

当你用std::vector实现了这些数据结构后，你会对它们的性能特征（何时快、何时慢）有更深刻的理解。例如，你就能明白为什么在vector中间插入元素是O(n)的（因为需要移动后面所有元素），而std::list（双向链表）在中间插入是O(1)的。

最后，我个人最深刻的体会是：不要孤立地学习语法。把数组和指针、内存、函数调用、标准库容器联系起来看。当你写arr[i]时，想想它背后是*(arr + i)；当你传递数组给函数时，想想它退化成指针后丢失了什么信息；当你需要动态数组时，先问问自己“这里用vector是不是更安全省心？”。数组是C++的基石之一，透彻地理解它，是你写出高效、健壮C++代码的必经之路。很多高级话题，比如迭代器、智能指针、移动语义，其设计思想都能在数组和指针这里找到源头。把这个基础打牢，后面的路会顺畅很多。