复制带有指向另一个对象的引用或指针的对象 [duplicate]

问：

我正在设计一个游戏，我需要复制某些组件。

这是我需要的：

class Common { };

class Component
{
private:

    Common &_commRef;

public:
    
    Component(Common &commRef) :_commRef{ commRef }{}
};

int main()
{
    Common common;
    Component componentA(common);
    Component componentB(common);
    Component compCopy(common);
    
    compCopy = componentA; //can't do this
    
    return 0;
}

但是，由于引用无法重新插入，因此我无法复制到 。这个问题在这里被问到：复制一个带有引用类型的成员变量的 C++ 类，但我的问题是关于答案本身。componentAcompCopy

因此，可能的解决方案是：

将原始指针传递给 Component 的构造函数，而不是引用：

class Common { };

class Component
{
private:

    Common *_commPtr;

public:
    
    Component(Common *commPtr) :_commPtr{ commPtr }{}
};

int main()
{
    Common common;
    Component componentA(&common);
    Component componentB(&common);
    Component compCopy(&common);
    
    compCopy = componentA; 
    
    return 0;
}

我不确定这是否是个好主意，因为班级现在可以做一些奇怪的事情，比如打电话。ComponentdeletecommPtr

传递智能指针：

class Common { };

class Component
{
private:

    std::shared_ptr<Common> _commPtr;

public:
    
    Component(std::shared_ptr<Common> commPtr) :_commPtr{ commPtr }{}
};

int main()
{
    std::shared_ptr<Common> commPtr = std::make_shared<Common>();
    Component componentA(commPtr);
    Component componentB(commPtr);
    Component compCopy(commPtr);

    compCopy = componentA; 
    
    return 0;
}

使用这种方法，我们在第一种方法中没有问题，但我不必要地在堆上创建一个对象，而不是第一种方法在堆栈上创建它。我的理解是使用堆栈，除非我们正在创建大型对象（创建对象经常被误用/过度使用？Commonnew

使用参考包装器（如链接的答案中所示）：

class Common { };

class Component
{
private:

    std::reference_wrapper<Common> _commRef;

public:
    
    Component(Common &commRef):_commRef{commRef}
    {}
};

int main()
{
    
    Common common;
    Component componentA(common);
    Component componentB(common);
    Component compCopy(common);

    compCopy = componentA; 
    
    return 0;
}

我应该更喜欢哪一个？或者，有没有其他方法？

使用引用包装器看起来最干净。它有缺点吗？