如何实现含多态std::unique_ptr映射的可复制Edge类？

这问题在C++里挺常见的——当你的类持有一个存有多态对象的std::unique_ptr容器时，默认的拷贝构造/赋值肯定用不了，因为unique_ptr本身是不可复制的，而且多态对象需要深拷贝才能真正复制内容。我给你一套完整的解决方案：

第一步：给边信息基类添加克隆接口 #

首先，你的边信息基类必须提供一个纯虚的clone方法，让每个子类都能返回自己的深拷贝。这是多态拷贝的核心：

#include <memory>
#include <typeindex>
#include <map>

// 边信息基类
class EdgeInfoBase {
public:
    // 虚析构函数，确保子类对象能正确销毁
    virtual ~EdgeInfoBase() = default;
    // 纯虚克隆方法，返回当前对象的深拷贝（unique_ptr形式）
    virtual std::unique_ptr<EdgeInfoBase> clone() const = 0;
};

// 示例子类：带权重的边信息
class EdgeWeightInfo : public EdgeInfoBase {
private:
    double weight;
public:
    EdgeWeightInfo(double w) : weight(w) {}
    // 实现克隆方法，返回当前对象的深拷贝
    std::unique_ptr<EdgeInfoBase> clone() const override {
        // 用make_unique创建子类对象，拷贝当前实例的内容
        return std::make_unique<EdgeWeightInfo>(*this);
    }
    // 其他成员函数...
    double get_weight() const { return weight; }
};

第二步：实现Edge类的拷贝构造与赋值 #

现在可以在Edge类里实现拷贝逻辑，遍历原对象的std::map，对每个unique_ptr指向的多态对象调用clone()生成新的智能指针，同时用copy-and-swap idiom实现简洁安全的赋值运算符：

class Edge {
private:
    std::size_t from;
    std::size_t to;
    std::map<std::type_index, std::unique_ptr<EdgeInfoBase>> info_map;
public:
    // 默认构造函数
    Edge(std::size_t f, std::size_t t) : from(f), to(t) {}

    // 拷贝构造函数
    Edge(const Edge& other) : from(other.from), to(other.to) {
        // 遍历原map，逐个克隆多态对象
        for (const auto& [type_idx, info_ptr] : other.info_map) {
            // 调用clone得到新的unique_ptr，插入到当前map
            info_map.emplace(type_idx, info_ptr->clone());
        }
    }

    // 拷贝赋值运算符：用copy-and-swap idiom，简洁且异常安全
    Edge& operator=(Edge other) {
        // 交换当前对象和临时对象的成员
        std::swap(from, other.from);
        std::swap(to, other.to);
        std::swap(info_map, other.info_map);
        return *this;
    }

    // 其他成员函数：比如添加边信息
    template<typename InfoType, typename... Args>
    void add_info(Args&&... args) {
        info_map.emplace(
            std::type_index(typeid(InfoType)),
            std::make_unique<InfoType>(std::forward<Args>(args)...)
        );
    }

    // 获取边信息的方法
    template<typename InfoType>
    const InfoType* get_info() const {
        auto it = info_map.find(std::type_index(typeid(InfoType)));
        if (it != info_map.end()) {
            // 向下转型，因为我们确保类型匹配
            return static_cast<const InfoType*>(it->second.get());
        }
        return nullptr;
    }
};

关键细节说明 #

• clone方法的必要性：因为unique_ptr不能直接拷贝，而多态对象无法通过基类指针直接拷贝子类内容，所以必须让每个子类自己实现深拷贝逻辑。
• copy-and-swap idiom：拷贝赋值运算符用值传递参数（会先触发拷贝构造创建临时对象），然后交换成员。这样做的好处是：异常安全（如果拷贝构造出错，原对象不会被修改），而且代码简洁，不需要手动管理资源释放。
• 虚析构函数：基类必须声明虚析构，否则当通过unique_ptr<EdgeInfoBase>销毁子类对象时，只会调用基类析构，导致子类资源泄漏。

测试示例 #

你可以这样验证复制功能：

int main() {
    Edge e1(0, 1);
    e1.add_info<EdgeWeightInfo>(3.14);

    // 拷贝构造
    Edge e2 = e1;
    const EdgeWeightInfo* weight_info = e2.get_info<EdgeWeightInfo>();
    if (weight_info) {
        // 应该输出3.14
        std::cout << e2.get_info<EdgeWeightInfo>()->get_weight() << std::endl;
    }

    // 修改e1的信息，e2不受影响（深拷贝生效）
    e1.add_info<EdgeWeightInfo>(2.71);
    std::cout << e1.get_info<EdgeWeightInfo>()->get_weight() << std::endl; // 2.71
    std::cout << e2.get_info<EdgeWeightInfo>()->get_weight() << std::endl; // 3.14

    return 0;
}

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