Effective Modern C++ 条款20：避免返回数组

条款20的核心目标是：规避C++原生数组作为函数返回值时的固有缺陷，转而使用现代C++标准库组件（std::vector/std::array），从根本上解决数组返回时的“内存安全”“大小未知”“类型退化”三大问题。

一、为什么不能返回原生数组？

C++原生数组不具备“值语义”（无法直接拷贝），且在函数返回时会发生**“数组到指针的退化”**（Array-to-Pointer Decay）——即返回的“数组”本质是指向数组首元素的裸指针。这种退化会导致三个致命问题：

1. 问题1：返回的指针可能指向“悬空内存”

若返回的是栈上局部数组的指针，函数执行结束后栈帧销毁，数组内存被释放，此时返回的指针变为“悬空指针”，调用者使用该指针会触发未定义行为（访问已释放内存）。

错误示例：返回局部数组指针

// 错误：返回栈上局部数组的指针，函数结束后arr内存被释放
int* getLocalArray() {
    int arr[3] = {1, 2, 3}; // 栈上数组，函数退出后销毁
    return arr; // 数组退化为int*，指向已销毁的内存
}

int main() {
    int* p = getLocalArray(); 
    std::cout << p[0]; // 未定义行为：访问悬空指针
    return 0;
}

2. 问题2：内存泄漏风险（若返回堆上数组）

若为避免栈内存释放，改用new[]在堆上分配数组并返回指针，虽能避免悬空，但调用者必须手动调用delete[]释放内存——一旦忘记，就会导致内存泄漏；且delete[]与new[]必须配对，若误写为delete，还会触发未定义行为。

错误示例：返回堆上数组指针

// 风险：调用者需手动delete[]，易遗漏导致内存泄漏
int* getHeapArray() {
    int* arr = new int[3]{1, 2, 3}; // 堆上数组
    return arr; // 返回int*，需调用者释放
}

int main() {
    int* p = getHeapArray();
    // 若忘记写 delete[] p; 则内存泄漏
    delete[] p; // 必须配对，否则泄漏
    return 0;
}

3. 问题3：调用者无法获知数组大小

数组退化为指针后，指针仅存储“首元素地址”，不包含任何大小信息。调用者若想遍历数组，必须额外传递大小（如返回std::pair<int*, size_t>），但这种方式易出错（大小与指针不匹配导致越界），且不符合现代C++的简洁性原则。

繁琐且危险的“指针+大小”方案

// 繁琐：需额外返回大小，且无法保证大小与指针匹配
std::pair<int*, size_t> getArrayWithSize() {
    int* arr = new int[3]{1, 2, 3};
    return {arr, 3}; // 手动绑定指针与大小
}

int main() {
    auto [p, size] = getArrayWithSize();
    // 若误写为 size=4，循环会越界访问
    for (size_t i = 0; i < size; ++i) {
        std::cout << p[i];
    }
    delete[] p; // 仍需手动释放
    return 0;
}

二、现代C++的解决方案：用标准容器替代原生数组

条款20明确推荐：用std::vector<T>（动态大小）或std::array<T, N>（固定大小）替代原生数组作为返回值。这两个容器均具备“值语义”（支持直接拷贝/移动），且内置“大小信息”，完全规避了原生数组的缺陷。

1. 方案1：返回std::vector<T>（动态大小场景）

std::vector是动态数组的安全封装，具备以下优势：

• 自动内存管理：无需手动new/delete，RAII机制确保离开作用域时释放内存，杜绝泄漏；
• 内置大小信息：通过size()成员函数直接获取数组长度，避免越界；
• 高效返回：C++11后支持移动语义，返回vector时会自动触发移动构造（无拷贝开销），性能接近原生数组。

正确示例：返回std::vector<int>

// 安全：vector自动管理内存，内置大小，返回时移动无开销
std::vector<int> getVectorArray() {
    std::vector<int> vec = {1, 2, 3}; // 无需手动管理内存
    return vec; // C++11后自动移动（而非拷贝）
}

int main() {
    auto vec = getVectorArray();
    // 安全遍历：通过size()获取长度，无越界风险
    for (size_t i = 0; i < vec.size(); ++i) {
        std::cout << vec[i];
    }
    // 无需手动释放，vec析构时自动释放内存
    return 0;
}

2. 方案2：返回std::array<T, N>（固定大小场景）

若数组大小是编译期确定的固定值，std::array是更优选择——它在栈上存储（无堆内存开销），大小编译期固定，性能与原生数组完全一致，同时保留了vector的安全性（值语义、内置大小）。

正确示例：返回std::array<int, 3>

// 更高效：固定大小，栈上存储，无堆内存开销
std::array<int, 3> getFixedArray() {
    std::array<int, 3> arr = {1, 2, 3}; // 栈上存储，与原生数组性能一致
    return arr; // 直接值返回（拷贝开销小，编译器可能优化为NRVO）
}

int main() {
    auto arr = getFixedArray();
    // 安全遍历：size()是编译期常量（3）
    for (size_t i = 0; i < arr.size(); ++i) {
        std::cout << arr[i];
    }
    // 无需释放，栈上内存自动回收
    return 0;
}

三、条款20的核心思想总结

1. 原生数组不适合作为返回值：其“数组到指针的退化”特性会导致悬空指针、内存泄漏、大小未知三大问题，违背现代C++的“安全优先”原则；
2. 优先选择标准容器替代：
   • 动态大小需求 → 用std::vector<T>（自动内存管理+动态扩容）；
   • 固定大小需求 → 用std::array<T, N>（栈上存储+编译期大小，性能最优）；
3. 符合现代C++设计哲学：vector/array具备“值语义”和“RAII特性”，无需手动管理内存，且内置大小信息，从根本上消除了原生数组的安全隐患，同时兼顾效率与可读性。