C++ 从函数返回数组

在 C++ 编程中，从函数返回数组是一个常见需求，但与返回简单数据类型相比，它更复杂一些。这主要是因为在 C++ 中，数组名实际上是指向第一个元素的指针，而不是可以直接复制的值。本文将介绍几种从函数返回数组的方法，并讨论每种方法的优缺点。

为什么从函数返回数组很复杂？

在 C++ 中，我们不能直接返回一个普通数组，比如：

cpp

// 错误❌ - 这段代码无法编译
int[] getArray() {
    int arr[5] = {1, 2, 3, 4, 5};
    return arr;  // 错误：无法返回局部数组
}

这段代码无法工作的原因是：

1. 数组 arr 是函数内的局部变量，函数结束后它的内存会被释放
2. C++ 不允许直接复制或返回整个数组

返回数组的几种方法

让我们来看看在 C++ 中从函数返回数组的几种常用方法：

1. 使用指针返回动态分配的数组

这是一种基础但需要小心的方法：

cpp

int* createArray(int size) {
    int* arr = new int[size];  // 动态分配内存
    for (int i = 0; i < size; i++) {
        arr[i] = i * 10;
    }
    return arr;  // 返回指针
}

// 使用示例
int main() {
    int* myArray = createArray(5);
    for (int i = 0; i < 5; i++) {
        std::cout << myArray[i] << " ";  // 输出: 0 10 20 30 40
    }
    delete[] myArray;  // 重要：必须手动释放内存
    return 0;
}

警告

这种方法要注意内存管理！使用 new 分配的数组必须用 delete[] 释放，否则会造成内存泄漏。

2. 使用静态数组

如果你需要返回固定大小的数组，可以使用静态数组：

cpp

int* getStaticArray() {
    static int arr[5] = {1, 2, 3, 4, 5};
    return arr;
}

// 使用示例
int main() {
    int* arr = getStaticArray();
    for (int i = 0; i < 5; i++) {
        std::cout << arr[i] << " ";  // 输出: 1 2 3 4 5
    }
    return 0;
}

备注

静态数组在函数结束后仍然存在，所以不会有悬空指针问题。但这不是线程安全的方法，因为静态变量在所有函数调用间共享。

3. 通过引用或指针参数

更好的做法是通过参数传递数组：

cpp

void fillArray(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        arr[i] = i * i;
    }
}

// 使用示例
int main() {
    int myArray[5];
    fillArray(myArray, 5);
    for (int i = 0; i < 5; i++) {
        std::cout << myArray[i] << " ";  // 输出: 0 1 4 9 16
    }
    return 0;
}

4. 使用 std::vector 容器（推荐）

这是现代 C++ 中最推荐的方法：

cpp

#include <vector>
#include <iostream>

std::vector<int> createVector(int size) {
    std::vector<int> vec(size);
    for (int i = 0; i < size; i++) {
        vec[i] = i * 100;
    }
    return vec;  // C++ 会优化这个返回过程
}

// 使用示例
int main() {
    std::vector<int> myVector = createVector(5);
    for (int value : myVector) {
        std::cout << value << " ";  // 输出: 0 100 200 300 400
    }
    return 0;
}

提示

std::vector 不需要手动管理内存，并且可以自动处理复制、扩展等操作，是处理可变大小数组的理想选择。

5. 使用 std::array（固定大小数组）

如果数组大小是固定的，可以使用 std::array：

cpp

#include <array>
#include <iostream>

std::array<int, 5> createFixedArray() {
    std::array<int, 5> arr = {5, 4, 3, 2, 1};
    return arr;
}

// 使用示例
int main() {
    std::array<int, 5> myArray = createFixedArray();
    for (int value : myArray) {
        std::cout << value << " ";  // 输出: 5 4 3 2 1
    }
    return 0;
}

实际应用案例

案例 1：图像处理函数

假设我们正在编写一个简单的图像处理程序，需要一个函数来生成图像的灰度版本：

cpp

#include <vector>
#include <iostream>

// 将彩色图像转换为灰度图像
std::vector<std::vector<int>> convertToGrayscale(const std::vector<std::vector<int>>& colorImage) {
    int height = colorImage.size();
    int width = colorImage[0].size();
    
    // 创建结果灰度图像
    std::vector<std::vector<int>> grayscaleImage(height, std::vector<int>(width));
    
    // 处理每个像素
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            // 这里简化了，实际计算可能更复杂
            grayscaleImage[i][j] = colorImage[i][j] / 3;
        }
    }
    
    return grayscaleImage;
}

// 示例使用
int main() {
    // 创建一个简单的 3x3 彩色图像（简化表示）
    std::vector<std::vector<int>> colorImg = {
        {150, 30, 90},
        {60, 120, 180},
        {210, 240, 45}
    };
    
    // 转换为灰度
    std::vector<std::vector<int>> grayImg = convertToGrayscale(colorImg);
    
    // 显示结果
    for (const auto& row : grayImg) {
        for (int pixel : row) {
            std::cout << pixel << " ";
        }
        std::cout << std::endl;
    }
    
    return 0;
}

案例 2：数据排序与过滤

假设我们需要一个函数，从数据集中过滤出符合条件的元素：

cpp

#include <vector>
#include <iostream>
#include <string>

struct Student {
    std::string name;
    int score;
};

// 筛选出分数超过阈值的学生
std::vector<Student> filterStudents(const std::vector<Student>& students, int minScore) {
    std::vector<Student> filteredStudents;
    
    for (const auto& student : students) {
        if (student.score >= minScore) {
            filteredStudents.push_back(student);
        }
    }
    
    return filteredStudents;
}

// 示例使用
int main() {
    std::vector<Student> allStudents = {
        {"Alice", 95},
        {"Bob", 75},
        {"Charlie", 82},
        {"David", 65},
        {"Eve", 90}
    };
    
    // 筛选成绩 80 分以上的学生
    std::vector<Student> highScorers = filterStudents(allStudents, 80);
    
    // 显示结果
    std::cout << "高分学生名单：" << std::endl;
    for (const auto& student : highScorers) {
        std::cout << student.name << ": " << student.score << std::endl;
    }
    
    return 0;
}

各种方法的比较

方法	优点	缺点	适用场景
动态分配数组	可以创建任意大小的数组	需要手动管理内存，容易出错	低级操作，与C代码交互
静态数组	简单，不需要内存管理	只能用于固定大小，非线程安全	简单的固定大小数组
引用/指针参数	高效，没有复制开销	调用方需要预先分配内存	高性能场景
std::vector	自动内存管理，大小可变	相比原始数组有轻微性能开销	大多数现代C++代码
std::array	无指针开销，大小在编译时确定	大小固定	性能敏感的固定大小数组

最佳实践

1. 优先使用 std::vector 或 std::array：它们提供内存安全和易用性
2. 避免返回原始动态分配的数组：除非有特殊的性能要求
3. 使用智能指针：如果必须返回动态分配的数组，考虑使用 std::unique_ptr
4. 函数参数优于返回值：如果可能，通过参数修改数组比返回新数组更高效

总结

从 C++ 函数返回数组有多种方法，每种方法各有优缺点：

• 动态分配数组需要手动管理内存，但提供完全控制
• 静态数组简单但有很多限制
• 通过参数传递数组是一种常用且高效的方法
• std::vector 和 std::array 是现代 C++ 中处理数组的首选方法

随着你编程技能的提高，建议逐渐转向使用 std::vector 和 std::array 这些更安全、更现代的容器，它们可以避免许多与原始数组相关的陷阱和错误。

练习

1. 编写一个函数，返回一个包含斐波那契数列前 n 项的 std::vector
2. 实现一个函数，接收一个整数数组，返回一个新数组，包含原数组中的偶数元素
3. 创建一个矩阵转置函数，接收一个二维数组并返回其转置结果（使用 std::vector<std::vector<int>>）
4. 比较使用指针返回动态数组和使用 std::vector 的性能差异

通过这些练习，你将更好地理解并掌握在 C++ 中从函数返回数组的各种技巧和最佳实践。