C++计算接口设计：统一处理不同结果所有权场景

这问题挺典型的——既要维持单一函数接口，又要处理三种不同生命周期的计算结果，还要避免MB级数据的不必要拷贝，确实得花点心思。我给你推荐几个从实际项目里验证过的方案，按易用性和安全性排序：

方案1：用std::variant实现类型安全的多态返回（C++17及以上） #

这是最直接的标准库方案，不需要自定义类，利用std::variant封装两种核心返回类型：

• 对于前两类场景（栈上层对象/缓存对象）：返回std::reference_wrapper<const T>（包装const左值引用，让它能放进variant）
• 对于第三类场景（不缓存的临时结果）：返回std::unique_ptr<T>（通过智能指针转移所有权，完全避免拷贝）

函数实现示例 #

#include <variant>
#include <memory>
#include <functional>

using ResultVariant = std::variant<std::reference_wrapper<const MyLargeCollection>, std::unique_ptr<MyLargeCollection>>;

ResultVariant compute(const Input& input) {
    if (is_stack_upper_case(input)) {
        const MyLargeCollection& ref = get_stack_upper_collection(input);
        return std::ref(ref);
    } else if (is_cached_case(input)) {
        const MyLargeCollection& cached = get_cached_collection(input);
        return std::ref(cached);
    } else {
        auto result = std::make_unique<MyLargeCollection>(compute_non_cached(input));
        return std::move(result);
    }
}

调用者使用示例 #

调用者可以用std::visit来统一处理两种情况，或者按需提取引用/所有权：

auto result = compute(my_input);

// 只读访问（所有场景通用）
std::visit([](const auto& val) {
    const MyLargeCollection& col = [&]() -> const MyLargeCollection& {
        if constexpr (std::is_same_v<std::decay_t<decltype(val)>, std::reference_wrapper<const MyLargeCollection>>) {
            return val.get();
        } else {
            return *val;
        }
    }();
    // 使用col做只读操作
}, result);

// 若需要获取所有权（仅第三类场景可用）
if (auto* ptr = std::get_if<std::unique_ptr<MyLargeCollection>>(&result)) {
    MyLargeCollection owned = std::move(**ptr);
    // 现在owned拥有数据所有权，可以修改或长期持有
}

方案2：自定义结果持有者类（更友好的封装） #

如果觉得std::variant的访问方式不够直观，可以封装一个自定义类，对外提供统一的访问接口，内部处理不同存储方式的细节：

#include <variant>
#include <memory>
#include <functional>
#include <stdexcept>

class CollectionResult {
public:
    // 构造：接受栈/缓存的const引用
    CollectionResult(const MyLargeCollection& ref) : storage_(std::ref(ref)) {}
    // 构造：接受转移所有权的unique_ptr
    CollectionResult(std::unique_ptr<MyLargeCollection> ptr) : storage_(std::move(ptr)) {}

    // 统一获取const引用（所有场景通用）
    const MyLargeCollection& get() const {
        return std::visit([](const auto& val) -> const MyLargeCollection& {
            using ValType = std::decay_t<decltype(val)>;
            if constexpr (std::is_same_v<ValType, std::reference_wrapper<const MyLargeCollection>>) {
                return val.get();
            } else {
                return *val;
            }
        }, storage_);
    }

    // 转移所有权（仅非缓存场景可用，否则抛出异常）
    std::unique_ptr<MyLargeCollection> take_ownership() {
        if (auto* ptr = std::get_if<std::unique_ptr<MyLargeCollection>>(&storage_)) {
            return std::move(*ptr);
        }
        throw std::runtime_error("Cannot take ownership of a referenced collection");
    }

private:
    std::variant<std::reference_wrapper<const MyLargeCollection>, std::unique_ptr<MyLargeCollection>> storage_;
};

// 函数返回自定义类型
CollectionResult compute(const Input& input) {
    // ... 逻辑和方案1类似，返回对应构造的CollectionResult
}

调用者使用示例 #

这个接口对调用者更友好，不需要直接处理variant的细节：

auto result = compute(my_input);

// 只读访问
const MyLargeCollection& col = result.get();
process_collection(col);

// 按需获取所有权
try {
    auto owned = result.take_ownership();
    modify_collection(*owned);
} catch (const std::runtime_error& e) {
    // 处理无法获取所有权的情况
}

关键注意事项 #

• 引用生命周期安全：返回栈上层对象的引用时，必须确保该对象的生命周期长于调用者对引用的使用周期（比如不能返回函数局部栈变量的引用，否则会导致悬空引用）。
• 避免不必要拷贝：MB级数据绝对要避免拷贝，所以第三类场景一定要用std::unique_ptr或移动语义转移所有权，不能直接返回值（除非你确定编译器能做NRVO优化，但智能指针更稳妥）。
• C++版本兼容性：如果你的项目还在用C++11/14，没法用std::variant，可以用boost::variant替代，或者用继承+多态的方式（但多态需要基类，对于集合类可能不太方便）。

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