桥接模式和组合模式的区别

桥接模式（Bridge Pattern）和组合模式（Composite Pattern）都是结构型设计模式，旨在解决对象结构的复杂性问题，但它们的应用场景和目的有所不同。以下是它们的区别：

1. 定义与目的

桥接模式（Bridge Pattern）：

• 定义：将抽象部分与它的实现部分分离，使它们可以独立地变化。
• 目的：主要解决在多维度变化情况下，类的爆炸性增长问题。通过将两个或多个维度的变化分离到不同的类层次中，从而使得系统更具灵活性。

组合模式（Composite Pattern）：

• 定义：将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
• 目的：主要解决对象的层次结构问题，使得客户端可以一致地处理单个对象和组合对象。

2. 主要使用场景

桥接模式：

• 当一个类有多个变化维度，并且这些维度需要独立变化时使用桥接模式。例如，一个图形类可能有形状和颜色两个变化维度，那么可以将形状和颜色分离为两个独立的层次结构。
• 当不希望在抽象和实现之间产生紧耦合时。

组合模式：

• 当需要表示对象的部分-整体层次结构时使用组合模式。
• 当希望客户端可以统一地处理单个对象和组合对象时。

3. 结构区别

桥接模式：包含两个独立的层次结构，一个是抽象部分，一个是实现部分。抽象部分包含对实现部分的引用。

组合模式：包含一个对象树的层次结构，叶子节点表示基本对象，组合节点表示容器对象。容器对象可以包含叶子节点或其他容器节点。

4. 示例代码对比

桥接模式（Bridge Pattern）

目的：将抽象部分与它的实现部分分离，使它们可以独立地变化。

类比

想象一下，你在设计一种绘图应用程序，这个应用程序可以绘制不同种类的形状（例如，圆形和方形），而每种形状可以用不同的颜色来绘制（例如，红色和蓝色）。在这种情况下，形状与颜色是两个独立的维度。

如果不用桥接模式，你可能会为每种情况创建一个类：

• 红色的圆形
• 蓝色的圆形
• 红色的方形
• 蓝色的方形

这样类的数量会随着形状和颜色的增加而成倍增长（组合爆炸）。

桥接模式的解决方案：

将形状和颜色分开处理。你创建一个形状的抽象类，并且它包含一个颜色的接口。然后你可以独立地扩展形状和颜色。

// 颜色接口
class Color {
public:
    virtual std::string fill() const = 0;
    virtual ~Color() = default;
};

class Red : public Color {
public:
    std::string fill() const override {
        return "红色";
    }
};

class Blue : public Color {
public:
    std::string fill() const override {
        return "蓝色";
    }
};

// 形状抽象类
class Shape {
protected:
    std::shared_ptr<Color> color;
public:
    Shape(std::shared_ptr<Color> col) : color(col) {}
    virtual std::string draw() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    Circle(std::shared_ptr<Color> col) : Shape(col) {}
    std::string draw() const override {
        return "绘制一个" + color->fill() + "的圆形";
    }
};

class Square : public Shape {
public:
    Square(std::shared_ptr<Color> col) : Shape(col) {}
    std::string draw() const override {
        return "绘制一个" + color->fill() + "的方形";
    }
};

// 使用
int main() {
    std::shared_ptr<Color> red = std::make_shared<Red>();
    std::shared_ptr<Color> blue = std::make_shared<Blue>();

    std::shared_ptr<Shape> redCircle = std::make_shared<Circle>(red);
    std::shared_ptr<Shape> blueSquare = std::make_shared<Square>(blue);

    std::cout << redCircle->draw() << std::endl; // 输出: 绘制一个红色的圆形
    std::cout << blueSquare->draw() << std::endl; // 输出: 绘制一个蓝色的方形

    return 0;
}

组合模式（Composite Pattern）

目的：将对象组合成树形结构以表示"部分-整体"的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

类比

想象一下，你在设计一个公司组织架构，这个组织架构中有部门和员工。部门可以包含子部门和员工，子部门又可以包含员工或更多的子部门，形成一个树形结构。

组合模式的解决方案：

你创建一个通用的组件接口，它可以表示部门和员工，然后通过组合对象来表示部门，通过叶子对象来表示员工。

#include <iostream>
#include <vector>
#include <memory>
#include <algorithm>

// 组件接口
class Employee {
public:
    virtual void showDetails() const = 0;
    virtual void add(std::shared_ptr<Employee> employee) {}
    virtual void remove(std::shared_ptr<Employee> employee) {}
    virtual ~Employee() = default;
};

// 叶子节点
class Developer : public Employee {
private:
    std::string name;
public:
    Developer(const std::string& devName) : name(devName) {}
    void showDetails() const override {
        std::cout << "开发者: " << name << std::endl;
    }
};

// 叶子节点
class Designer : public Employee {
private:
    std::string name;
public:
    Designer(const std::string& desName) : name(desName) {}
    void showDetails() const override {
        std::cout << "设计师: " << name << std::endl;
    }
};

// 容器节点
class Manager : public Employee {
private:
    std::string name;
    std::vector<std::shared_ptr<Employee>> subordinates;
public:
    Manager(const std::string& mgrName) : name(mgrName) {}
    void showDetails() const override {
        std::cout << "经理: " << name << std::endl;
        for (const auto& subordinate : subordinates) {
            subordinate->showDetails();
        }
    }
    void add(std::shared_ptr<Employee> employee) override {
        subordinates.push_back(employee);
    }
    void remove(std::shared_ptr<Employee> employee) override {
        subordinates.erase(std::remove(subordinates.begin(), subordinates.end(), employee), subordinates.end());
    }
};

// 使用
int main() {
    std::shared_ptr<Employee> dev1 = std::make_shared<Developer>("Alice");
    std::shared_ptr<Employee> dev2 = std::make_shared<Developer>("Bob");
    std::shared_ptr<Employee> des1 = std::make_shared<Designer>("Charlie");

    std::shared_ptr<Manager> mgr1 = std::make_shared<Manager>("Dave");
    mgr1->add(dev1);
    mgr1->add(dev2);
    mgr1->add(des1);

    std::shared_ptr<Employee> des2 = std::make_shared<Designer>("Eve");

    std::shared_ptr<Manager> generalManager = std::make_shared<Manager>("Frank");
    generalManager->add(mgr1);
    generalManager->add(des2);

    generalManager->showDetails();
    // 输出:
    // 经理: Frank
    // 经理: Dave
    // 开发者: Alice
    // 开发者: Bob
    // 设计师: Charlie
    // 设计师: Eve

    return 0;
}

总结

• 桥接模式：
  • 用于分离抽象和实现，使它们可以独立变化。
  • 适用于多维度变化的场景，如形状和颜色的组合。
• 组合模式：
  • 用于构建对象的树形结构，使得单个对象和组合对象可以一致地处理。
  • 适用于表示部分-整体层次结构的场景，如公司组织架构。