编辑“︁C++ 从函数返回数组”︁（章节）

= C++从函数返回数组 =

在C++编程中，数组是一种基础数据结构，但直接返回数组会遇到一些技术挑战。本文将详细解释在C++中从函数返回数组的各种方法，包括它们的优缺点和适用场景。

== 基本概念 ==
在C++中，数组名本质上是指向数组第一个元素的指针。由于数组的这种特性，函数不能直接返回一个原生数组，但可以通过以下几种方式间接实现：

1. 返回指向静态数组的指针
2. 返回动态分配的数组（使用new）
3. 使用结构体或类包装数组
4. 使用标准库容器（如std::array或std::vector）

== 方法一：返回静态数组指针 ==
静态数组的生命周期贯穿整个程序运行期间，因此可以安全地返回其指针。

<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

int* getStaticArray() {
    static int arr[3] = {1, 2, 3}; // 静态数组
    return arr;
}

int main() {
    int* ptr = getStaticArray();
    cout << "数组元素: ";
    for(int i = 0; i < 3; ++i) {
        cout << ptr[i] << " ";
    }
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
数组元素: 1 2 3 
</pre>

'''注意事项:'''
* 静态数组会一直占用内存
* 不是线程安全的
* 所有调用共享同一数组实例

== 方法二：返回动态分配数组 ==
使用new运算符在堆上分配数组，需要调用者负责内存释放。

<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

int* createDynamicArray(int size) {
    int* arr = new int[size];
    for(int i = 0; i < size; ++i) {
        arr[i] = i * 10;
    }
    return arr;
}

int main() {
    int size = 5;
    int* dynArr = createDynamicArray(size);
    
    cout << "动态数组: ";
    for(int i = 0; i < size; ++i) {
        cout << dynArr[i] << " ";
    }
    
    delete[] dynArr; // 必须释放内存
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
动态数组: 0 10 20 30 40 
</pre>

'''注意事项:'''
* 必须手动管理内存
* 容易导致内存泄漏
* 建议使用智能指针替代原始指针

== 方法三：使用结构体/类包装 ==
将数组封装在结构体中可以解决返回问题，因为结构体是可以完整返回的。

<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

struct ArrayWrapper {
    int data[5];
};

ArrayWrapper getArray() {
    ArrayWrapper arr;
    for(int i = 0; i < 5; ++i) {
        arr.data[i] = i + 1;
    }
    return arr;
}

int main() {
    ArrayWrapper result = getArray();
    cout << "包装数组: ";
    for(int i = 0; i < 5; ++i) {
        cout << result.data[i] << " ";
    }
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
包装数组: 1 2 3 4 5 
</pre>

'''优点:'''
* 不需要动态内存管理
* 类型安全
* 支持值语义

== 方法四：使用标准库容器 ==
现代C++推荐使用标准库容器如std::array或std::vector。

=== 使用std::array ===
<syntaxhighlight lang="cpp">
#include <iostream>
#include <array>
using namespace std;

array<int, 4> getStdArray() {
    return {10, 20, 30, 40};
}

int main() {
    auto arr = getStdArray();
    cout << "std::array元素: ";
    for(auto num : arr) {
        cout << num << " ";
    }
    return 0;
}
</syntaxhighlight>

=== 使用std::vector ===
<syntaxhighlight lang="cpp">
#include <iostream>
#include <vector>
using namespace std;

vector<int> getVector() {
    return {1, 3, 5, 7, 9};
}

int main() {
    auto vec = getVector();
    cout << "vector元素: ";
    for(auto num : vec) {
        cout << num << " ";
    }
    return 0;
}
</syntaxhighlight>

'''优点:'''
* 自动内存管理
* 支持动态大小（vector）
* 丰富的成员函数
* 与现代C++特性良好集成

== 性能比较 ==
以下是不同方法的性能特点比较：

<mermaid>
barChart
    title 不同返回数组方法的比较
    x-axis 方法
    y-axis 性能
    series 内存管理
    series 安全性
    series 灵活性
    
    "静态数组" : 3, 2, 1
    "动态数组" : 1, 1, 3
    "结构体包装" : 3, 3, 2
    "std::array" : 3, 3, 2
    "std::vector" : 2, 3, 3
</mermaid>

== 实际应用案例 ==
考虑一个图像处理函数，需要返回处理后的像素数据：

<syntaxhighlight lang="cpp">
#include <vector>
#include <cmath>

using namespace std;

// 返回应用高斯模糊后的像素数据
vector<double> applyGaussianBlur(const vector<double>& input, int width, int height) {
    vector<double> output(input.size());
    // 这里实现实际的高斯模糊算法
    // 简化为示例：
    for(int i = 0; i < input.size(); ++i) {
        output[i] = input[i] * 0.8; // 简化的"模糊"效果
    }
    return output;
}
</syntaxhighlight>

== 数学表达 ==
当处理数值数组时，可能会涉及数学运算。例如，计算数组的点积可以表示为：

<math>
\vec{a} \cdot \vec{b} = \sum_{i=1}^{n} a_i b_i
</math>

== 总结 ==
* 对于固定大小数组，优先使用std::array
* 对于动态大小数组，使用std::vector
* 避免使用原始指针和手动内存管理
* 结构体包装适合需要值语义的简单场景
* 静态数组仅适用于特定场景（如小型查找表）

现代C++的最佳实践是尽可能使用标准库容器，它们提供了更好的安全性、可维护性和性能。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 数组]]