突破编程_C++_设计模式（组合模式）

代码一：

以下是一个简单的示例，展示了如何在C++中使用组合模式来构建一个简单的文件系统目录结构。

#include 
#include 
#include 
 
// 抽象构件角色：文件系统对象
class FileSystemObject {
public:
    virtual void add(FileSystemObject*) {}
    virtual void remove(FileSystemObject*) {}
    virtual void display() {}
    virtual ~FileSystemObject() {}
};
 
// 叶子构件角色：文件
class File : public FileSystemObject {
public:
    void display() override {
        std::cout << "文件" << std::endl;
    }
};
 
// 组合构件角色：目录
class Directory : public FileSystemObject {
private:
    std::vector components;
    std::string name;
 
public:
    Directory(const std::string& name) : name(name) {}
 
    void add(FileSystemObject* obj) override {
        components.push_back(obj);
    }
 
    void remove(FileSystemObject* obj) override {
        for (auto it = components.begin(); it != components.end(); ++it) {
            if (*it == obj) {
                components.erase(it);
                break;
            }
        }
    }
 
    void display() override {
        std::cout << "目录: " << name << std::endl;
        for (auto& component : components) {
            component->display();
        }
    }
 
    ~Directory() {
        for (auto& component : components) {
            delete component;
        }
    }
};
 
int main() {
    // 创建文件系统对象
    FileSystemObject* rootDir = new Directory("根目录");
    FileSystemObject* binDir = new Directory("bin");
    FileSystemObject* usrDir = new Directory("usr");
    FileSystemObject* binFile = new File();
    FileSystemObject* usrFile = new File();
 
    // 构建文件系统目录结构
    rootDir->add(binDir);
    rootDir->add(usrDir);
    binDir->add(binFile);
    usrDir->add(usrFile);
 
    // 显示文件系统目录结构
    rootDir->display();
 
    // 清理内存
    delete rootDir;
 
    return 0;
}

这段代码首先定义了一个抽象构件类FileSystemObject，以及两个继承自它的具体构件类File和Directory。Directory类中使用了一个vector来存储子对象，并实现了add和remove方法来管理这些子对象。在main函数中，我们创建了一个层次化的文件系统目录结构，并展示了目录结构。最后，记得删除所有动态分配的对象以避免内存泄漏。 

代码二：

组合模式是一种结构型设计模式，它允许将对象组合成树状结构，并且能够以统一的方式处理单个对象和组合对象。

在组合模式中，有两种类型的对象：叶子对象和组合对象。叶子对象代表单个对象，而组合对象代表一组对象的集合。

组合模式的核心思想是，将对象组织成树状结构，使得客户端可以像处理单个对象一样处理组合对象和叶子对象。通过统一的接口，客户端可以递归地处理对象树的每个节点。

以下是一个使用组合模式的简单示例，假设我们要建立一个文件系统结构：

#include 
#include 

// 抽象组件
class FileSystemComponent {
public:
    virtual void display() = 0;
};

// 叶子组件
class File : public FileSystemComponent {
private:
    std::string name;

public:
    File(std::string name) : name(name) {}

    void display() {
        std::cout << "File: " << name << std::endl;
    }
};

// 组合组件
class Folder : public FileSystemComponent {
private:
    std::string name;
    std::vector children;

public:
    Folder(std::string name) : name(name) {}

    void add(FileSystemComponent* component) {
        children.push_back(component);
    }

    void display() {
        std::cout << "Folder: " << name << std::endl;

        for (FileSystemComponent* component : children) {
            component->display();
        }
    }
};

int main() {
    // 创建文件和文件夹对象
    File* file1 = new File("file1.txt");
    File* file2 = new File("file2.jpg");
    Folder* folder1 = new Folder("folder1");
    Folder* folder2 = new Folder("folder2");

    // 组合文件和文件夹对象
    folder1->add(file1);
    folder2->add(file2);
    folder2->add(folder1);

    // 显示文件系统结构
    folder2->display();

    return 0;
}

输出结果为： 

Folder: folder2
File: file2.jpg
Folder: folder1
File: file1.txt

在这个示例中，我们通过File类和Folder类分别表示文件和文件夹对象。FileSystemComponent是一个抽象基类，定义了统一的接口display()。File类和Folder类都实现了display()方法。Folder类还包含一个std::vector容器，用于存储其子组件。

在主函数中，我们创建了两个文件对象(file1和file2)和两个文件夹对象(folder1和folder2)，并将它们组合成树状结构。最后，调用folder2的display()方法，输出整个文件系统的结构。

通过组合模式，我们可以方便地处理复杂的对象结构，并且可以以统一的方式处理单个对象和组合对象。这使得我们可以更加灵活地组织和操作对象，同时提高了代码的可维护性和可扩展性。