C++如何正确将计算结果数据指针赋值给传入函数的vector输出参数

触发coredump的核心原因是悬空指针访问：

• 你通过get_output()拿到的tmp是m_layers_[j]内部持有的裸指针，指向的内存归layer对象所有，predict函数执行结束后，layer大概率会复用、覆写甚至释放这块内存用于下一次计算。
• 你当前的set_data只是把指针地址存到了output对象的data_成员里，既没有拷贝实际数据，也没有持有这块内存的所有权，函数退出后data_指向的内存已经失效，外部访问自然触发段错误。
• 现有Tensor类只有裸指针存储能力，没有内存生命周期管理、数据拷贝的相关逻辑，无法保障外部访问时内存有效。

方案1：为Tensor增加独立内存管理与数据拷贝能力（推荐，工业级框架通用实现） #

核心思路是让每个输出Tensor自己持有独立的内存，把计算结果拷贝到自己的内存空间，完全和layer内部的临时内存解耦，从根源避免悬空指针问题。

第一步：改造Tensor类 #

#pragma once
#include <cstddef>
#include <cstring>
#include <vector>

// 工具函数：返回对应数据类型的单元素字节数
size_t get_dtype_size(DataType type) {
  switch(type) {
    case DataType_DT_FLOAT: return 4;
    case DataType_DT_INT32: return 4;
    case DataType_DT_INT8: return 1;
    default: return 0;
  }
}

class Tensor {
public:
  Tensor(DeviceType dev = DeviceType_kCPU) : dev_(dev) {}
  ~Tensor() {
    // 仅释放自己持有所有权的内存，避免误释放外部传入的内存
    if (data_ && is_owner_) {
      // CPU内存用free，GPU内存替换为cudaFree等对应设备的释放接口
      free(data_);
    }
  }
  // 禁用默认浅拷贝，避免同一块内存被多次释放
  Tensor(const Tensor&) = delete;
  Tensor& operator=(const Tensor&) = delete;
  // 支持移动语义，减少不必要的内存拷贝
  Tensor(Tensor&& other) noexcept {
    type_ = other.type_;
    dev_ = other.dev_;
    data_ = other.data_;
    dims_ = other.dims_;
    is_owner_ = other.is_owner_;
    other.data_ = nullptr;
    other.is_owner_ = false;
  }

public:
  void *get_data() { return data_; }
  const void *get_data() const { return data_; }
  // 原有set_data接口保留，增加所有权标记
  void set_data(void *data_ptr, bool is_owner = false) { 
    if (data_ && is_owner_) free(data_);
    data_ = data_ptr; 
    is_owner_ = is_owner;
  }
  // 新增：根据维度、数据类型分配自有内存
  void resize(const std::vector<size_t>& dims, DataType type = DataType_DT_FLOAT) {
    dims_ = dims;
    type_ = type;
    size_t total_elem = 1;
    for (auto d : dims_) total_elem *= d;
    size_t total_bytes = total_elem * get_dtype_size(type_);
    if (data_ && is_owner_) free(data_);
    data_ = malloc(total_bytes);
    is_owner_ = true;
  }
  // 新增：从外部源内存拷贝数据到当前Tensor的自有内存
  void copy_from(const void* src, size_t copy_bytes) {
    memcpy(data_, src, copy_bytes);
  }

protected:
  DataType type_ = DataType_DT_FLOAT;
  DeviceType dev_ = DeviceType::DeviceType_kX86;
  void *data_ = nullptr;
  std::vector<size_t> dims_ = {};
  bool is_owner_ = false; // 标记当前Tensor是否持有data_指向内存的所有权
};

第二步：修改predict函数的赋值逻辑 #

不要直接存layer的内部指针，先给output分配自有内存，再把数据拷贝过去：

bool predict(const std::vector<Tensor> &inputs,
                  std::vector<Tensor> &outputs, int batch_size,
                  std::string &err_msg) {
  // 前向计算逻辑执行前，先给每个输出Tensor分配对应大小的内存
  // 维度根据你模型的实际输出shape修改，以下为示例
  for (int j = 0; j < outputs.size(); j++) {
    outputs[j].resize({(size_t)batch_size, 1000}, DataType_DT_FLOAT);
  }

  // ... 省略原有模型前向计算的逻辑 ...

  for (int j = 0; j < m_layers_.size(); j++) {
    auto tmp = m_layers_[j]->get_output();
    // 计算需要拷贝的总字节数，根据layer输出的实际维度、数据类型计算
    size_t copy_bytes = /* 示例：batch_size * 1000 * 4 */;
    // 把layer内部的计算结果拷贝到output自己持有的内存中
    outputs[j].copy_from(tmp, copy_bytes);
  }
  return true;
}

改造后只要output对象生命周期没结束，外部访问其数据永远有效，不会出现悬空指针问题。

方案2：延长layer内部内存生命周期（仅适合性能极端敏感、内存逻辑100%可控的场景） #

如果不想做数据拷贝，可以直接复用layer的内部内存，但必须满足两个硬约束：

• layer对象的生命周期必须长于外部使用outputs的周期，不能在outputs用完前销毁layer
• layer不能在后续前向计算时覆写、释放这块输出内存，需要为每次predict保留独立的输出内存
• 调用set_data时明确标记is_owner=false，避免Tensor析构时释放归layer所有的内存

风险提示：该方案耦合度极高，后续只要修改layer的内存复用逻辑、调整对象生命周期就会重新触发coredump，非必要不使用。

方案3：用智能指针替代裸指针做内存管理 #

如果不想手动实现所有权标记，可以把data_的类型改为std::shared_ptr<void>，配合对应设备的自定义删除器，通过引用计数自动管理内存生命周期，只要还有Tensor持有该内存的引用，内存就不会被释放，本质和方案1的目标一致，只是用标准库组件减少手动管理内存的代码量。

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