如何在C++中为类成员实现有条件所有权转移（无堆分配）

你的需求完全可以实现，下面提供两种无需堆分配的方案，分别基于标准库工具和手动联合体管理：

方案一：使用std::variant + std::reference_wrapper #

std::variant不能直接存储引用，因此用std::reference_wrapper<T>包装引用类型，让variant同时支持存储T（拥有所有权）和std::reference_wrapper<T>（持有引用）两种状态。

#include <variant>
#include <functional>

template<typename T>
struct C {
    std::variant<T, std::reference_wrapper<T>> m_t;

    // 绑定左值，持有引用
    C(T& t) : m_t(std::ref(t)) {}

    // 绑定右值，转移所有权（避免不必要的拷贝）
    C(T&& t) : m_t(std::move(t)) {}

    // 统一的访问接口
    T& get() {
        return std::visit([](auto& val) -> T& {
            if constexpr (std::is_same_v<std::decay_t<decltype(val)>, T>) {
                return val;
            } else {
                return val.get();
            }
        }, m_t);
    }

    const T& get() const {
        return std::visit([](const auto& val) -> const T& {
            if constexpr (std::is_same_v<std::decay_t<decltype(val)>, T>) {
                return val;
            } else {
                return val.get();
            }
        }, m_t);
    }
};

这个方案无需手动管理内存，依赖标准库自动处理成员的构造、析构和访问，代码简洁且安全。

方案二：手动管理的联合体（适合追求极致性能场景） #

通过联合体存储T实例和T&引用，配合一个标记位跟踪当前激活的成员类型。这种方式需要手动处理生命周期，代码更繁琐，但可以避免std::variant的少量运行时开销。

template<typename T>
struct C {
    union {
        T owned_t;
        T& ref_t;
    };
    bool is_owned; // 标记当前是拥有所有权还是持有引用

    // 绑定左值引用
    C(T& t) : ref_t(t), is_owned(false) {}

    // 绑定右值，获取所有权
    C(T&& t) : owned_t(std::move(t)), is_owned(true) {}

    // 手动处理析构
    ~C() {
        if (is_owned) {
            owned_t.~T();
        }
        // 引用无需析构
    }

    // 禁用拷贝（若需要拷贝需手动实现，避免引用浅拷贝问题）
    C(const C&) = delete;
    C& operator=(const C&) = delete;

    // 移动构造
    C(C&& other) noexcept {
        if (other.is_owned) {
            new (&owned_t) T(std::move(other.owned_t));
            other.owned_t.~T();
            is_owned = true;
        } else {
            ref_t = other.ref_t;
            is_owned = false;
        }
    }

    // 移动赋值
    C& operator=(C&& other) noexcept {
        if (this != &other) {
            // 先清理当前拥有的对象
            if (is_owned) {
                owned_t.~T();
            }
            // 转移状态
            if (other.is_owned) {
                new (&owned_t) T(std::move(other.owned_t));
                other.owned_t.~T();
                is_owned = true;
            } else {
                ref_t = other.ref_t;
                is_owned = false;
            }
        }
        return *this;
    }

    // 统一访问接口
    T& get() {
        return is_owned ? owned_t : ref_t;
    }

    const T& get() const {
        return is_owned ? owned_t : ref_t;
    }
};

注意事项 #

• 无论哪种方案，当C持有引用时，被引用的对象生命周期必须长于C，否则会出现悬空引用问题。
• 如果T是不可移动类型，方案一中的右值构造需改为m_t(t)（拷贝构造）。

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