第五节 · 瓶子与漏水防护 · 数组库与再探原生数组

我们已经学习了 vector，它是 C++ 中最常用的动态数组。但有时候，我们确实知道数组的大小，而且不需要动态改变它。这时候，C++11 引入的 std::array 可能是更好的选择。

同时，理解原生数组的细节，对于深入理解 C++ 也是非常必要的。

---

std::array

std::array 是对原生数组的封装，它的大小在编译时确定，不能改变：

#include <array>
#include <iostream>
using namespace std;

int main()
{
    // 声明一个包含 5 个整数的 array
    array<int, 5> arr = {1, 2, 3, 4, 5};
    
    // 访问元素
    cout << arr[0] << endl;      // 1
    cout << arr.at(1) << endl;   // 2（带边界检查）
    
    // 获取大小
    cout << arr.size() << endl;  // 5
    
    // 遍历
    for (int x : arr)
    {
        cout << x << " ";
    }
    cout << endl;
    
    return 0;
}

array vs 原生数组

// 原生数组
int arr1[5] = {1, 2, 3, 4, 5};

// std::array
array<int, 5> arr2 = {1, 2, 3, 4, 5};

std::array 的优势：

1. 知道自己的大小：arr2.size() 返回 5，而原生数组不能这样。

2. 可以赋值和比较：array 支持 =、==、< 等运算符。

3. 支持迭代器：可以使用 begin()、end() 等。

4. 更安全：at() 方法有边界检查。

5. 可以作为函数返回值：原生数组不能直接返回。

array<int, 5> arr1 = {1, 2, 3, 4, 5};
array<int, 5> arr2 = {1, 2, 3, 4, 5};
array<int, 5> arr3 = {5, 4, 3, 2, 1};

// 赋值
arr3 = arr1;  // 原生数组不能这样做

// 比较
if (arr1 == arr2)
    cout << "arr1 和 arr2 相等" << endl;

// 作为函数返回值
array<int, 3> getArray()
{
    return {1, 2, 3};
}

---

再探原生数组

虽然 vector 和 array 更加安全和方便，但理解原生数组仍然很重要，因为：

1. 很多旧代码使用原生数组

2. 与 C 语言交互时需要用到

3. 理解底层原理有助于写出更好的代码

数组名是指向首元素的指针

int arr[5] = {10, 20, 30, 40, 50};

// 数组名可以当作指针使用
int* p = arr;        // arr 隐式转换为 &arr[0]

cout << *p << endl;  // 10
cout << *arr << endl;// 10

// 指针算术
cout << *(p + 1) << endl;    // 20
cout << *(arr + 2) << endl;  // 30

// 等价关系
// arr[i] 等价于 *(arr + i)
// &arr[i] 等价于 arr + i

但要注意，数组名和指针并不完全相同：

int arr[5];
int* p = arr;

cout << sizeof(arr) << endl;  // 20（5 个 int，每个 4 字节）
cout << sizeof(p) << endl;    // 8（指针的大小，64 位系统）

字符数组与 C 风格字符串

C 风格字符串就是以空字符 \0 结尾的字符数组：

char str1[] = "Hello";        // 自动添加 \0，长度为 6
char str2[] = {'H', 'e', 'l', 'l', 'o', '\0'};  // 等价写法
char str3[10] = "Hi";         // 前两个字符是 Hi，第三个是 \0，后面未初始化

// 字符串长度（不包括 \0）
cout << strlen(str1) << endl;  // 5

// 字符串操作（需要 <cstring>）
char dest[20];
strcpy(dest, str1);           // 复制字符串
strcat(dest, " World");       // 拼接字符串
cout << dest << endl;         // Hello World
cout << strcmp("abc", "abd") << endl;  // 比较字符串，返回负数

C 风格字符串的危险之处在于容易越界：

char small[5];
strcpy(small, "This is a very long string");  // 危险！缓冲区溢出

这就是为什么我们更推荐使用 std::string。

---

数组作为函数参数

当数组作为函数参数时，会退化为指针：

void printArray(int arr[], int size)  // arr 实际上是 int* 类型
{
    // sizeof(arr) 在这里返回的是指针的大小，而不是数组的大小
    for (int i = 0; i < size; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main()
{
    int nums[] = {1, 2, 3, 4, 5};
    printArray(nums, 5);  // 必须另外传递大小
    return 0;
}

以下三种声明方式是等价的：

void func(int arr[]);
void func(int arr[10]);   // 这里的 10 会被忽略
void func(int* arr);

使用 std::array 可以避免这个问题：

void printArray(const array<int, 5>& arr)  // 保留了大小信息
{
    for (int x : arr)
    {
        cout << x << " ";
    }
    cout << endl;
}

---

多维数组

// 二维数组
int matrix[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// 访问元素
cout << matrix[1][2] << endl;  // 7

// 遍历
for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 4; j++)
    {
        cout << matrix[i][j] << " ";
    }
    cout << endl;
}

多维数组在内存中是连续存储的，按行优先顺序：

内存布局: [1][2][3][4][5][6][7][8][9][10][11][12]

多维数组作为参数

// 除了第一维，其他维度的大小必须指定
void printMatrix(int arr[][4], int rows)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
}

---

使用指针遍历数组

int arr[] = {10, 20, 30, 40, 50};
int* begin = arr;
int* end = arr + 5;  // 指向最后一个元素之后

for (int* p = begin; p != end; ++p)
{
    cout << *p << " ";
}
cout << endl;

这种模式与标准库容器的迭代器非常相似，这也是 C++ 设计迭代器时参考的原型。

C++11 提供了 std::begin() 和 std::end() 函数，可以用于原生数组：

#include <iterator>

int arr[] = {10, 20, 30, 40, 50};

for (auto it = begin(arr); it != end(arr); ++it)
{
    cout << *it << " ";
}
cout << endl;

// 也可以用于标准库算法
sort(begin(arr), end(arr));

---

总结对比

特性	原生数组	std::array	std::vector
大小	编译时确定	编译时确定	运行时可变
内存位置	栈或静态区	栈或静态区	堆
边界检查	无	at() 有	at() 有
赋值	不支持	支持	支持
作为参数	退化为指针	保持类型	保持类型
作为返回值	不能	可以	可以

选择建议：

• 大小固定且已知：优先使用 std::array

• 大小动态变化：使用 std::vector

• 与 C 代码交互：可能需要使用原生数组

---

习题

• 使用 std::array 存储一周七天的名称，并遍历输出。

• 编写一个函数，接收一个原生整数数组和它的大小，返回数组中的最大值。

• 使用二维数组实现一个简单的井字棋棋盘，并编写函数打印棋盘状态。