C++数组乘积函数输出垃圾值，疑悬空指针，是否需动态内存分配？

你的代码存在两个核心问题，直接导致了垃圾值输出：

1. 返回栈内存局部变量的指针（悬空指针） #

apply_all函数里的new_array是栈上的局部数组，函数执行结束后，栈帧会被销毁，这块内存会被系统回收或重新分配。此时返回的指针指向的是已经无效的内存区域，属于典型的悬空指针，后续访问该指针指向的内容会触发未定义行为，表现为输出垃圾值。

2. 返回的指针位置错误 #

循环中你持续对array_ptr执行自增操作，最终返回的是数组末尾的下一个位置，而不是新数组的起始地址。即便内存有效，后续print函数访问的也是超出数组范围的区域，同样会读取到垃圾数据。

解决方案：使用动态内存分配 #

你确实需要通过动态内存分配来解决这个问题，因为只有堆上的内存不会随函数返回而被释放。修正后的代码如下：

#include <iostream>

using namespace std;

void print(int array[], size_t array_size);
int *apply_all(int array1[], size_t size1, int array2[], size_t size2);

void print(int array[], size_t array_size) {
    cout << "[ ";
    for (size_t i{0}; i < array_size; ++i)
        cout << array[i] << " ";
    cout << "]" << endl;
}

int *apply_all(int array1[], size_t size1, int array2[], size_t size2) {
    // 用new[]在堆上分配内存
    int *new_array = new int[size1 * size2]{};
    int *array_ptr = new_array; // 保存数组起始地址
    for (size_t i_1{0}; i_1 < size1; ++i_1) {
        for (size_t i_2{0}; i_2 < size2; ++i_2) {
            *array_ptr = array1[i_1] * array2[i_2];
            array_ptr++;
        }
    }
    return new_array; // 返回数组起始地址，而非移动后的指针
}

int main() {
    const size_t array1_size {5};
    const size_t array2_size {3};

    int array1 [] {1,2,3,4,5};
    int array2 [] {10,20,30};

    cout << "Array 1: ";
    print(array1, array1_size);

    cout << "Array 2: ";
    print(array2, array2_size);

    int *results = apply_all(array1, array1_size, array2, array2_size);
    constexpr size_t results_size {array1_size * array2_size};

    cout << "Result: ";
    print(results, results_size);

    // 手动释放堆内存，避免内存泄漏
    delete[] results;
    results = nullptr; // 将指针置空，防止悬空
}

更推荐的现代C++方案：使用std::vector #

手动管理动态内存容易出现泄漏或野指针问题，现代C++中更建议使用std::vector来自动管理内存，代码更简洁安全：

#include <iostream>
#include <vector>

using namespace std;

void print(const vector<int>& vec);
vector<int> apply_all(const int array1[], size_t size1, const int array2[], size_t size2);

void print(const vector<int>& vec) {
    cout << "[ ";
    for (int num : vec)
        cout << num << " ";
    cout << "]" << endl;
}

vector<int> apply_all(const int array1[], size_t size1, const int array2[], size_t size2) {
    vector<int> result;
    result.reserve(size1 * size2); // 预分配内存提升效率
    for (size_t i_1{0}; i_1 < size1; ++i_1) {
        for (size_t i_2{0}; i_2 < size2; ++i_2) {
            result.push_back(array1[i_1] * array2[i_2]);
        }
    }
    return result;
}

int main() {
    const size_t array1_size {5};
    const size_t array2_size {3};

    int array1 [] {1,2,3,4,5};
    int array2 [] {10,20,30};

    cout << "Array 1: ";
    print(vector<int>(array1, array1 + array1_size));

    cout << "Array 2: ";
    print(vector<int>(array2, array2 + array2_size));

    vector<int> results = apply_all(array1, array1_size, array2, array2_size);

    cout << "Result: ";
    print(results);
}

内容的提问来源于stack exchange，提问作者PardonMySkillz