C++如何将对象所有权传递给组合类？解决悬垂引用问题

我有一个类A，希望存储另一个类型为B、名为m的对象，该对象由创建A的函数传入。B的创建由一个我无法控制的外部DLL函数createB()完成。现有伪代码如下：

class A
{
public:
    A(B& m)
    {
        this->m = m;
    }

private:
    B& m;
};

// 调用代码
void SomeLongLivedClass::someFunction()
{
    B m = createB();
    A* a = new A{ m }; // 修正原代码笔误，补充指针分配逻辑

    // m 离开作用域被销毁
}

当someFunction()作用域结束时，局部对象m被销毁，导致A中存储的引用变成悬垂引用。我只能通过createB()获取合法的B对象，且无法修改该函数的实现。现在有几个疑问：

1. 如何让m的所有权传递给A，避免悬垂引用？
2. 为了简化A的代码而在外部创建B的做法，是否从根本上错误？这种将对象塞入类中的方式，是否符合组合的设计思想？
3. 考虑过用std::unique_ptr<B>传递m，但不确定是否还会出现悬垂问题？

注：以上是伪代码，实际场景中B的创建流程更复杂，因此希望在A外部完成B的创建。

解决方案与解答 #

1. 如何传递B的所有权给A #

核心问题是你之前的A仅存储了B的引用，未获取所有权。要解决悬垂问题，需让A真正拥有B的所有权，有两种可行方案：

方案1：让A直接存储B的实例

将A的成员从B&改为B，构造时直接接收B的实例，优先用移动构造减少拷贝开销：

class A
{
public:
    // 直接接收B的实例，通过std::move转移所有权
    A(B m) : m(std::move(m)) {}

private:
    B m; // 存储实例而非引用
};

// 调用时直接传递createB的返回值，省略局部变量
void SomeLongLivedClass::someFunction()
{
    A* a = new A{ createB() };
}

此时A自身持有B的实例，不存在局部对象销毁导致的悬垂问题。只要B支持移动构造（C++类默认支持，除非手动禁用），效率与拷贝几乎无差异。

方案2：用std::unique_ptr管理B的生命周期

如果B体积较大、需要多态，或必须在堆上分配，可通过智能指针转移所有权：

class A
{
public:
    // 接收unique_ptr，通过std::move转移所有权
    A(std::unique_ptr<B> m_ptr) : m_ptr(std::move(m_ptr)) {}

private:
    std::unique_ptr<B> m_ptr;
};

// 调用代码
void SomeLongLivedClass::someFunction()
{
    // 将createB的结果封装进unique_ptr
    auto m_ptr = std::make_unique<B>(createB());
    // 转移所有权给A，原局部m_ptr会被置空
    A* a = new A{ std::move(m_ptr) };
}

局部的m_ptr在std::move后会失去对B的所有权，它销毁时不会释放B，A内的m_ptr成为新的所有者，完全不会出现悬垂问题。

2. 在外部创建B是否错误？组合的实现是否正确？ #

这种做法完全合理，反而符合单一职责原则：A只需专注自身逻辑，无需关心B的创建细节，代码更简洁清晰。

你之前的问题并非“在外部创建B”，而是用了聚合的方式（存储引用）却期望组合的效果：

• 组合是指A拥有B的所有权，B的生命周期依赖于A（A销毁时B也随之销毁）。只要A持有B的实例或带所有权的智能指针，就是标准的组合实现，完全正确。
• 聚合是A仅持有B的引用/指针，但不负责B的生命周期，这才会出现生命周期不匹配的问题——也就是你遇到的悬垂引用。

3. std::unique_ptr<B>是否会导致悬垂？ #

不会。std::unique_ptr的核心特性是独占所有权，当你通过std::move将其传递给A后，原局部unique_ptr会彻底失去对B的控制权，A内的unique_ptr成为新的所有者。局部unique_ptr销毁时，因已无所有权，不会释放B对象，因此A内的指针完全有效，不存在悬垂。

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