11.设计模式实战：从创建型到结构型的全面解析

设计模式实战：从创建型到结构型的全面解析

前言

设计模式是软件开发中解决常见问题的经典方案，掌握设计模式不仅能提升代码质量，还能让我们与团队更好地沟通设计思想。本文将从创建型模式和结构型模式两大类别出发，结合实际C++代码，详解10个最常用的设计模式。

工厂模式、建造者模式、原型模式、桥接模式、适配器模式、装饰模式、组合模式、享元模式、外观模式、代理模式

一、创建型模式

创建型模式关注对象创建机制，使系统在创建对象时更加灵活、解耦。

1. 工厂模式

工厂模式的核心思想是将对象的创建和使用分离，由专门的“工厂”负责创建对象。

三种工厂模式对比

代码示例：工厂方法

// 抽象产品
class Car {
public:
    virtual void run() = 0;
    virtual ~Car() = default;
};

// 具体产品
class Bmw : public Car {
public:
    void run() override { std::cout << "宝马在飞驰" << std::endl; }
};

// 抽象工厂
class CarFactory {
public:
    virtual std::unique_ptr<Car> createCar() = 0;
    virtual ~CarFactory() = default;
};

// 具体工厂
class BmwFactory : public CarFactory {
public:
    std::unique_ptr<Car> createCar() override {
        return std::make_unique<Bmw>();
    }
};

// 使用
int main() {
    std::unique_ptr<CarFactory> factory = std::make_unique<BmwFactory>();
    auto car = factory->createCar();
    car->run(); // 输出：宝马在飞驰
}

2. 建造者模式

建造者模式将复杂对象的构建与表示分离，使同样的构建过程可以创建不同的表示。

经典实现 vs 链式调用

代码示例：链式调用

class Pizza {
public:
    class Builder {
        Pizza pizza_;
    public:
        Builder& setSize(const std::string& size) {
            pizza_.size_ = size;
            return *this;
        }
        Builder& addCheese() {
            pizza_.cheese_ = true;
            return *this;
        }
        Pizza build() { return pizza_; }
    };
    
private:
    std::string size_;
    bool cheese_ = false;
};

// 使用
Pizza pizza = Pizza::Builder()
    .setSize("大份")
    .addCheese()
    .build();

3. 原型模式

原型模式通过复制现有对象来创建新对象，避免昂贵的初始化操作。

深拷贝 vs 浅拷贝

代码示例

// 抽象原型
class Shape {
public:
    virtual std::unique_ptr<Shape> clone() const = 0;
    virtual void draw() const = 0;
    virtual ~Shape() = default;
};

// 具体原型
class Circle : public Shape {
private:
    int radius;
    std::string color;
    
public:
    Circle(int r, const std::string& c) : radius(r), color(c) {}
    
    // 拷贝构造函数（深拷贝）
    Circle(const Circle& other) = default;
    
    std::unique_ptr<Shape> clone() const override {
        return std::make_unique<Circle>(*this);
    }
    
    void draw() const override {
        std::cout << "Circle: radius=" << radius << ", color=" << color << std::endl;
    }
};

// 使用
int main() {
    auto original = std::make_unique<Circle>(10, "red");
    auto cloned = original->clone();  // 多态克隆
    cloned->draw();
}

二、结构型模式

结构型模式关注如何将类和对象组合成更大的结构。

4. 桥接模式

桥接模式将抽象部分与实现部分分离，使它们可以独立变化。

解决什么问题？

问题：有M种形状和N种颜色，使用继承需要创建 M×N 个类。

解决：桥接模式只需 M + N 个类。

代码示例

// 实现部分：颜色接口
class Color {
public:
    virtual void applyColor() const = 0;
};

class Red : public Color {
public:
    void applyColor() const override {
        std::cout << "应用红色" << std::endl;
    }
};

// 抽象部分：形状
class Shape {
protected:
    std::shared_ptr<Color> color_;
public:
    Shape(std::shared_ptr<Color> color) : color_(color) {}
    virtual void draw() const = 0;
};

class Circle : public Shape {
public:
    Circle(std::shared_ptr<Color> color) : Shape(color) {}
    void draw() const override {
        std::cout << "绘制圆形，";
        color_->applyColor();
    }
};

// 使用
int main() {
    auto red = std::make_shared<Red>();
    auto circle = Circle(red);
    circle.draw();  // 绘制圆形，应用红色
}

5. 适配器模式

适配器模式让不兼容的接口能够一起工作。

类适配器 vs 对象适配器

代码示例：对象适配器

// 目标接口（客户端期望）
class ChineseSocket {
public:
    virtual void charge_220v() const {
        std::cout << "使用220V电压充电" << std::endl;
    }
};

// 适配者（需要适配的类）
class USASocket {
public:
    void charge_110v() const {
        std::cout << "使用110V电压充电" << std::endl;
    }
};

// 适配器
class USAAdapter : public ChineseSocket {
private:
    std::unique_ptr<USASocket> usa_socket_;
public:
    USAAdapter(std::unique_ptr<USASocket> socket) 
        : usa_socket_(std::move(socket)) {}
    
    void charge_220v() const override {
        std::cout << "[适配器] 将110V转换为220V: ";
        usa_socket_->charge_110v();
    }
};

// 使用
int main() {
    auto usaSocket = std::make_unique<USASocket>();
    USAAdapter adapter(std::move(usaSocket));
    adapter.charge_220v();  // 美国插座也能在中国使用
}

6. 装饰模式

装饰模式动态地给对象添加新功能，比继承更灵活。

装饰模式 vs 继承

代码示例：咖啡订单系统

// 抽象组件
class Beverage {
public:
    virtual std::string getDescription() const = 0;
    virtual double cost() const = 0;
    virtual ~Beverage() = default;
};

// 具体组件
class Espresso : public Beverage {
public:
    std::string getDescription() const override { return "浓缩咖啡"; }
    double cost() const override { return 25.0; }
};

// 抽象装饰类
class CondimentDecorator : public Beverage {
protected:
    std::unique_ptr<Beverage> beverage_;
public:
    CondimentDecorator(std::unique_ptr<Beverage> bev) 
        : beverage_(std::move(bev)) {}
};

// 具体装饰：牛奶
class Milk : public CondimentDecorator {
public:
    Milk(std::unique_ptr<Beverage> bev) 
        : CondimentDecorator(std::move(bev)) {}
    
    std::string getDescription() const override {
        return beverage_->getDescription() + " + 牛奶";
    }
    double cost() const override { return beverage_->cost() + 5.0; }
};

// 使用
int main() {
    auto coffee = std::make_unique<Espresso>();
    coffee = std::make_unique<Milk>(std::move(coffee));
    coffee = std::make_unique<Milk>(std::move(coffee));  // 双份牛奶
    
    std::cout << coffee->getDescription() << ": ¥" << coffee->cost() << std::endl;
    // 输出：浓缩咖啡 + 牛奶 + 牛奶: ¥35
}

7. 组合模式

组合模式将对象组合成树形结构，使客户端对单个对象和组合对象的使用具有一致性。

代码示例：公司组织架构

// 抽象组件
class Employee {
public:
    virtual void showInfo(int depth = 0) = 0;
    virtual void add(std::shared_ptr<Employee>) {}
    virtual ~Employee() = default;
};

// 叶子：普通员工
class OrdinaryEmployee : public Employee {
private:
    std::string name_;
    std::string position_;
public:
    OrdinaryEmployee(std::string name, std::string pos) 
        : name_(name), position_(pos) {}
    
    void showInfo(int depth = 0) override {
        std::string indent(depth * 2, ' ');
        std::cout << indent << "- " << name_ << " (" << position_ << ")" << std::endl;
    }
};

// 组合：经理
class Manager : public Employee {
private:
    std::string name_;
    std::string position_;
    std::vector<std::shared_ptr<Employee>> subordinates_;
public:
    Manager(std::string name, std::string pos) 
        : name_(name), position_(pos) {}
    
    void add(std::shared_ptr<Employee> emp) override {
        subordinates_.push_back(emp);
    }
    
    void showInfo(int depth = 0) override {
        std::string indent(depth * 2, ' ');
        std::cout << indent << "+ " << name_ << " (经理 - " << position_ << ")" << std::endl;
        for (auto& emp : subordinates_) {
            emp->showInfo(depth + 1);
        }
    }
};

// 使用
int main() {
    auto ceo = std::make_shared<Manager>("张三", "CEO");
    auto techManager = std::make_shared<Manager>("李四", "技术总监");
    auto dev = std::make_shared<OrdinaryEmployee>("王五", "工程师");
    
    ceo->add(techManager);
    techManager->add(dev);
    ceo->showInfo();
}

8. 享元模式

享元模式通过共享大量细粒度对象来减少内存占用。

内在状态 vs 外在状态

代码示例：字符共享

// 享元接口
class Character {
public:
    virtual void display(int fontSize, const std::string& color) = 0;
    virtual ~Character() = default;
};

// 具体享元
class ConcreteCharacter : public Character {
private:
    char symbol_;  // 内在状态（可共享）
public:
    ConcreteCharacter(char c) : symbol_(c) {}
    
    void display(int fontSize, const std::string& color) override {
        std::cout << "字符: " << symbol_ 
                  << ", 字号: " << fontSize 
                  << ", 颜色: " << color << std::endl;
    }
};

// 享元工厂
class CharacterFactory {
private:
    std::unordered_map<char, std::shared_ptr<Character>> pool_;
public:
    std::shared_ptr<Character> getCharacter(char key) {
        if (pool_.find(key) == pool_.end()) {
            pool_[key] = std::make_shared<ConcreteCharacter>(key);
            std::cout << "创建新字符: " << key << std::endl;
        }
        return pool_[key];
    }
    
    size_t size() const { return pool_.size(); }
};

// 使用
int main() {
    CharacterFactory factory;
    std::string text = "Hello";
    
    for (char c : text) {
        auto ch = factory.getCharacter(c);
        ch->display(12, "Black");
    }
    // 输出：只创建了4个字符对象（H,e,l,o），l被重用
    std::cout << "实际创建对象数: " << factory.size() << std::endl;
}

9. 外观模式

外观模式为子系统提供统一的简化接口。

代码示例：家庭影院

// 子系统类
class Projector {
public:
    void on() { std::cout << "投影仪打开" << std::endl; }
    void off() { std::cout << "投影仪关闭" << std::endl; }
};

class SoundSystem {
public:
    void on() { std::cout << "音响打开" << std::endl; }
    void setVolume(int level) { std::cout << "音量: " << level << std::endl; }
};

class BluRayPlayer {
public:
    void on() { std::cout << "播放器打开" << std::endl; }
    void play(const std::string& movie) { std::cout << "播放: " << movie << std::endl; }
};

// 外观类
class HomeTheaterFacade {
private:
    Projector* projector_;
    SoundSystem* sound_;
    BluRayPlayer* player_;
    
public:
    HomeTheaterFacade(Projector* p, SoundSystem* s, BluRayPlayer* b)
        : projector_(p), sound_(s), player_(b) {}
    
    void watchMovie(const std::string& movie) {
        std::cout << "=== 开始观影 ===" << std::endl;
        projector_->on();
        sound_->on();
        sound_->setVolume(30);
        player_->on();
        player_->play(movie);
        std::cout << "=== 观影中 ===" << std::endl;
    }
    
    void endMovie() {
        std::cout << "=== 结束观影 ===" << std::endl;
        projector_->off();
        sound_->off();
        player_->off();
    }
};

// 使用
int main() {
    Projector proj;
    SoundSystem sound;
    BluRayPlayer player;
    
    HomeTheaterFacade theater(&proj, &sound, &player);
    theater.watchMovie("盗梦空间");
    theater.endMovie();
}

10. 代理模式

代理模式为另一个对象提供替身以控制访问。

代理模式分类

代码示例：保护代理

// 抽象主题
class Document {
public:
    virtual void read() = 0;
    virtual void write(const std::string& content) = 0;
    virtual ~Document() = default;
};

// 真实主题
class RealDocument : public Document {
private:
    std::string content_;
public:
    void read() override { std::cout << "阅读: " << content_ << std::endl; }
    void write(const std::string& c) override { content_ = c; }
};

// 代理：带权限控制
class DocumentProxy : public Document {
private:
    std::unique_ptr<RealDocument> realDoc_;
    std::string userRole_;
    
    bool hasWritePermission() const {
        return userRole_ == "admin" || userRole_ == "editor";
    }
    
public:
    DocumentProxy(const std::string& role) 
        : realDoc_(std::make_unique<RealDocument>()), userRole_(role) {}
    
    void read() override {
        realDoc_->read();  // 所有人都可读
    }
    
    void write(const std::string& content) override {
        if (hasWritePermission()) {
            realDoc_->write(content);
            std::cout << "写入成功" << std::endl;
        } else {
            std::cout << "权限不足，无法写入" << std::endl;
        }
    }
};

// 使用
int main() {
    auto userDoc = DocumentProxy("user");
    userDoc.write("新内容");  // 失败
    
    auto adminDoc = DocumentProxy("admin");
    adminDoc.write("重要内容");  // 成功
}

三、模式对比总结

创建型模式对比

结构型模式对比

四、选择建议

核心原则

别一开始就上最复杂的设计。先用简单方案解决问题，当发现需要扩展时，再平滑地重构为更合适的设计模式。

五、设计模式应用场景速查表

1.创建型模式

2.结构型模式

3.快速决策矩阵