C++函数指针内存保存问题：void类型函数返回指针异常排查

兄弟，你的代码之所以编译通过但运行时触发异常，核心原因是局部vector的生命周期问题：

你在decompose函数里创建的AtmD和XsD是局部变量，当函数执行完毕返回时，这两个vector会被自动销毁，它们内部的内存也会被释放。此时你把&AtmD[0]和&XsD[0]赋值给外部的指针Atm和ID，本质上是让外部指针指向了已经被释放的内存——也就是所谓的悬空指针。后续在main里访问这些指针，会触发未定义行为（比如崩溃、乱码等）。

下面给你几种安全且符合C++最佳实践的解决方式，按推荐优先级排序：

1. 返回包含结果的结构体/pair #

直接让函数返回一个封装了两个vector的结构体，利用C++的返回值优化（RVO）避免不必要的拷贝，同时让内存管理完全交给vector自动处理：

// 先定义结果结构体
struct DecomposeResult {
    std::vector<double> atm_values;
    std::vector<int> id_values;
};

// 修改函数返回类型
DecomposeResult cracking::decompose(char input[][100], int size_S) {
    std::vector<double> AtmD;
    std::vector<int> XsD;
    
    // 这里执行你的分解逻辑，填充两个vector
    // ...
    
    // 构造结果并返回，用move避免拷贝（可选，但效率更高）
    DecomposeResult result;
    result.atm_values = std::move(AtmD);
    result.id_values = std::move(XsD);
    return result;
}

在main里调用的方式：

cracking obj;
auto result = obj.decompose(input, size_S);

// 直接使用result.atm_values和result.id_values即可
// 比如遍历输出：
for (double val : result.atm_values) {
    std::cout << val << " ";
}

2. 传入vector的引用作为参数 #

如果不想修改函数的返回类型，可以把输出用的vector以引用的形式传入函数，直接在原容器上填充数据：

void cracking::decompose(char input[][100], int size_S, std::vector<double>& atm_out, std::vector<int>& id_out) {
    // 先清空容器（如果需要覆盖原有数据的话）
    atm_out.clear();
    id_out.clear();
    
    // 执行分解逻辑，直接往atm_out和id_out里添加数据
    // 比如：atm_out.push_back(some_double_value);
    // ...
}

main里的调用方式：

cracking obj;
std::vector<double> atm_results;
std::vector<int> id_results;

obj.decompose(input, size_S, atm_results, id_results);

// 现在atm_results和id_results里已经有结果了

3. 动态分配数组（不推荐） #

如果一定要坚持用指针的方式传递结果，你需要手动用new分配内存（但要记得在外部手动释放，否则会内存泄漏）：

void cracking::decompose(char input[][100], int size_S, double* &Atm, int* &ID, int &size_out) {
    std::vector<double> AtmD;
    std::vector<int> XsD;
    
    // 执行分解逻辑，填充vector
    // ...
    
    size_out = AtmD.size();
    // 动态分配对应大小的数组
    Atm = new double[size_out];
    ID = new int[size_out];
    
    // 把vector里的数据拷贝到数组中
    std::copy(AtmD.begin(), AtmD.end(), Atm);
    std::copy(XsD.begin(), XsD.end(), ID);
}

main里调用后必须手动释放内存：

cracking obj;
double* atm_ptr = nullptr;
int* id_ptr = nullptr;
int output_size = 0;

obj.decompose(input, size_S, atm_ptr, id_ptr, output_size);

// 使用数据...
for (int i = 0; i < output_size; ++i) {
    std::cout << atm_ptr[i] << ", " << id_ptr[i] << std::endl;
}

// 用完后必须释放，否则内存泄漏
delete[] atm_ptr;
delete[] id_ptr;

优先选择前两种方案，因为它们完全利用C++的vector自动管理内存的特性，避免了悬空指针和内存泄漏的风险，代码也更简洁易维护。第三种方案需要手动管理内存，出错概率高，除非有特殊需求，否则不推荐使用。

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