C++如何实现动态复合对象集合管理

std::vector<std::unique_ptr<BaseComponent>>

unique_ptr

std::shared_ptr

#include <vector>
#include <memory> // For std::unique_ptr, std::shared_ptr
#include <iostream>
#include <string>
#include <algorithm> // For std::remove_if

// 抽象基类，定义组件的通用接口
class ComponentBase {
public:
    virtual ~ComponentBase() {
        std::cout << "ComponentBase destructor called.\n";
    }
    virtual void performAction() const = 0;
    virtual std::string getName() const = 0;
};

// 具体组件A
class ConcreteComponentA : public ComponentBase {
private:
    std::string id_;
public:
    ConcreteComponentA(std::string id) : id_(std::move(id)) {}
    ~ConcreteComponentA() override {
        std::cout << "ConcreteComponentA(" << id_ << ") destructor called.\n";
    }
    void performAction() const override {
        std::cout << "Component A (" << id_ << ") performing its specific action.\n";
    }
    std::string getName() const override { return "ConcreteComponentA-" + id_; }
};

// 具体组件B
class ConcreteComponentB : public ComponentBase {
private:
    std::string type_;
public:
    ConcreteComponentB(std::string type) : type_(std::move(type)) {}
    ~ConcreteComponentB() override {
        std::cout << "ConcreteComponentB(" << type_ << ") destructor called.\n";
    }
    void performAction() const override {
        std::cout << "Component B (" << type_ << ") handling its logic.\n";
    }
    std::string getName() const override { return "ConcreteComponentB-" + type_; }
};

// 复合对象
class CompositeObject {
private:
    std::string compositeName_;
    // 使用unique_ptr管理组件，表示独占所有权
    std::vector<std::unique_ptr<ComponentBase>> components_;

public:
    CompositeObject(std::string name) : compositeName_(std::move(name)) {
        std::cout << "CompositeObject '" << compositeName_ << "' created.\n";
    }

    // 析构函数，unique_ptr会自动销毁其管理的组件
    ~CompositeObject() {
        std::cout << "CompositeObject '" << compositeName_ << "' destructor called.\n";
        // components_ vector 会自动清空，其内部的unique_ptr会自动调用delete
    }

    // 添加组件，通过移动语义接收unique_ptr
    void addComponent(std::unique_ptr<ComponentBase> component) {
        if (component) {
            std::cout << "Adding component '" << component->getName() << "' to '" << compositeName_ << "'.\n";
            components_.push_back(std::move(component));
        }
    }

    // 遍历并执行所有组件的操作
    void executeAllComponentActions() const {
        std::cout << "\n--- " << compositeName_ << " executing all component actions ---\n";
        for (const auto& compPtr : components_) {
            if (compPtr) {
                compPtr->performAction();
            }
        }
        std::cout << "--------------------------------------------------------\n";
    }

    // 移除特定名称的组件
    void removeComponent(const std::string& componentName) {
        auto oldSize = components_.size();
        components_.erase(
            std::remove_if(components_.begin(), components_.end(),
                           [&](const std::unique_ptr<ComponentBase>& comp) {
                               return comp && comp->getName() == componentName;
                           }),
            components_.end());
        if (components_.size() < oldSize) {
            std::cout << "Removed component '" << componentName << "' from '" << compositeName_ << "'.\n";
        } else {
            std::cout << "Component '" << componentName << "' not found in '" << compositeName_ << "'.\n";
        }
    }

    // 获取组件数量
    size_t getComponentCount() const {
        return components_.size();
    }
};

// 示例用法
// int main() {
//     CompositeObject mainSystem("MainSystem");

//     // 添加不同类型的组件
//     mainSystem.addComponent(std::make_unique<ConcreteComponentA>("Logger"));
//     mainSystem.addComponent(std::make_unique<ConcreteComponentB>("NetworkHandler"));
//     mainSystem.addComponent(std::make_unique<ConcreteComponentA>("ConfigLoader"));

//     mainSystem.executeAllComponentActions();

//     // 移除一个组件
//     mainSystem.removeComponent("ConcreteComponentA-Logger");
//     mainSystem.executeAllComponentActions();

//     // 嵌套复合对象
//     auto subSystem = std::make_unique<CompositeObject>("SubSystem");
//     subSystem->addComponent(std::make_unique<ConcreteComponentB>("DatabaseConnector"));
//     mainSystem.addComponent(std::move(subSystem)); // 将子系统作为组件加入主系统

//     mainSystem.executeAllComponentActions();

//     std::cout << "\nMain system going out of scope. All components should be automatically cleaned up.\n";
//     return 0;
// }

new

delete

new

delete

delete

delete

delete

delete

delete

std::unique_ptr

std::unique_ptr

unique_ptr

unique_ptr

Car

Engine

Gearbox

Engine

Gearbox

Car

Car

Car

std::unique_ptr<Engine>

std::unique_ptr<Gearbox>

// 示例：Car 独占 Engine
class Engine { /* ... */ };
class Car {
    std::unique_ptr<Engine> engine_;
public:
    Car() : engine_(std::make_unique<Engine>()) {}
    // ...
};

std::shared_ptr

std::shared_ptr

shared_ptr

shared_ptr

shared_ptr

User

Document

SceneObject

Material

std::shared_ptr

// 示例：多个User共享同一个Document
class Document { /* ... */ };
class User {
    std::shared_ptr<Document> currentDoc_;
public:
    void openDocument(std::shared_ptr<Document> doc) {
        currentDoc_ = std::move(doc);
    }
    // ...
};

shared_ptr

shared_ptr

shared_ptr

std::weak_ptr

weak_ptr

shared_ptr

weak_ptr

shared_ptr