如何用现代C++实现组合模式？内存管理与拷贝构造难题

核心问题分析 #

你遇到的两个问题本质上都是多态拷贝的问题：

• 拷贝构造函数无法直接处理多态类型，必须通过虚克隆函数实现派生类的深拷贝
• std::initializer_list<Base&>中的元素是基类引用，需要克隆出对应派生类的实例才能存入std::unique_ptr

解决方案步骤 #

1. 给基类添加虚克隆接口 #

要实现多态拷贝，基类必须提供一个纯虚的clone函数，让每个派生类实现自己的拷贝逻辑：

class Component {
public:
    virtual ~Component() = default;
    // 虚克隆函数，返回当前对象的深拷贝
    virtual std::unique_ptr<Component> clone() const = 0;
    // 其他组合模式必需的接口，比如operation()
    virtual void operation() const = 0;
};

2. 实现Leaf和Composite的克隆函数 #

对于叶子节点，直接返回自身的unique_ptr拷贝；对于组合节点，需要递归克隆所有子节点：

class Leaf : public Component {
public:
    std::unique_ptr<Component> clone() const override {
        return std::make_unique<Leaf>(*this);
    }

    void operation() const override {
        std::cout << "Leaf operation\n";
    }
};

class Composite : public Component {
private:
    std::vector<std::unique_ptr<Component>> children;
public:
    // 克隆函数：递归拷贝所有子节点
    std::unique_ptr<Component> clone() const override {
        auto copy = std::make_unique<Composite>();
        for (const auto& child : children) {
            copy->children.push_back(child->clone());
        }
        return copy;
    }

    void operation() const override {
        std::cout << "Composite operation\n";
        for (const auto& child : children) {
            child->operation();
        }
    }
};

3. 修复Composite的拷贝构造函数 #

利用克隆函数实现深拷贝的拷贝构造：

// Composite的拷贝构造函数
Composite(const Composite& other) {
    for (const auto& child : other.children) {
        children.push_back(child->clone());
    }
}

4. 实现带std::initializer_list<Component&>的构造函数 #

因为initializer_list中的元素是基类引用，我们需要对每个元素调用clone()来创建派生类实例，再转移给unique_ptr：

Composite(std::initializer_list<Component&> init_list) {
    for (Component& comp : init_list) {
        children.push_back(comp.clone());
    }
}

注意：这里传入的init_list中的元素必须是可拷贝的（即已经正确实现了clone函数），否则会编译失败。

5. 完成copy-swap惯用法 #

先实现swap函数，再利用拷贝构造和swap实现赋值运算符：

// 友元swap函数，用于copy-swap
friend void swap(Composite& lhs, Composite& rhs) noexcept {
    using std::swap;
    swap(lhs.children, rhs.children);
}

// 赋值运算符：copy-swap惯用法
Composite& operator=(Composite other) noexcept {
    swap(*this, other);
    return *this;
}

完整示例代码 #

#include <iostream>
#include <vector>
#include <memory>
#include <utility>

class Component {
public:
    virtual ~Component() = default;
    virtual std::unique_ptr<Component> clone() const = 0;
    virtual void operation() const = 0;
};

class Leaf : public Component {
public:
    std::unique_ptr<Component> clone() const override {
        return std::make_unique<Leaf>(*this);
    }

    void operation() const override {
        std::cout << "Leaf operation\n";
    }
};

class Composite : public Component {
private:
    std::vector<std::unique_ptr<Component>> children;
public:
    Composite() = default;
    // 拷贝构造
    Composite(const Composite& other) {
        for (const auto& child : other.children) {
            children.push_back(child->clone());
        }
    }
    // initializer_list构造
    Composite(std::initializer_list<Component&> init_list) {
        for (Component& comp : init_list) {
            children.push_back(comp.clone());
        }
    }
    // 移动构造（默认生成即可）
    Composite(Composite&&) = default;

    std::unique_ptr<Component> clone() const override {
        return std::make_unique<Composite>(*this);
    }

    void operation() const override {
        std::cout << "Composite operation\n";
        for (const auto& child : children) {
            child->operation();
        }
    }

    // 添加子节点的接口
    void add(std::unique_ptr<Component> child) {
        children.push_back(std::move(child));
    }

    friend void swap(Composite& lhs, Composite& rhs) noexcept {
        using std::swap;
        swap(lhs.children, rhs.children);
    }

    Composite& operator=(Composite other) noexcept {
        swap(*this, other);
        return *this;
    }
};

int main() {
    Leaf leaf1, leaf2;
    Composite comp1{leaf1, leaf2};
    Composite comp2 = comp1; // 测试拷贝构造
    comp2.operation();

    Composite comp3;
    comp3 = comp1; // 测试赋值运算符
    comp3.operation();

    return 0;
}

关键说明 #

• 用std::unique_ptr管理子节点，确保内存安全（自动释放，无裸指针风险），且无shared_ptr的额外开销
• 虚克隆函数是实现多态深拷贝的核心，解决了拷贝构造无法处理多态类型的问题
• initializer_list<Component&>的构造通过克隆每个元素，确保存入的是独立的子对象实例，避免悬空引用或所有权问题

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