计算机基础（一）——设计模式

一、设计模式

设计模式（Design Patterns）是软件开发中反复出现问题的解决方案的通用描述。
它是经过总结、提炼的高效代码结构和设计方案，帮助开发者写出更灵活、可维护和可扩展的代码。

二、设计模式应用原则

三、设计模式的分类

设计模式一般分为三大类：

常见设计模式有单例模式、工厂模式、观察者模式、策略模式、代理模式、装饰器模式等。

四、常见设计模式——单例模式（Singleton Pattern）

1. 概念

单例模式（Singleton Pattern）是一种创建型设计模式，目的是：

确保一个类只有一个实例，并提供一个全局访问点。

• 单例模式提供 全局唯一实例控制，是一种非常常用的基础模式；
• 在多线程环境下注意加锁或使用现代 C++ 静态变量机制；
• 避免滥用，防止造成代码耦合和测试困难。

2. 使用场景

适用于以下场景：

3. 核心特点

• 构造函数私有化，防止外部创建对象。
• 提供静态方法，返回唯一实例。
• 类中保存唯一实例的静态指针。

4. C++ 中的经典实现（线程安全 + 懒汉式）

#include <iostream>
using namespace std;
#include <mutex>

class Singleton {
private:
    // 构造函数私有，防止外部构造
    Singleton()
    {
        cout << "构造 Singleton 对象" << endl;
    }

    // 禁用拷贝构造和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* instance;    // 静态指针
    static std::mutex mtx;         // 线程安全锁

public:
    static Singleton* getInstance()
    {
        // 双重检查锁定（Double-Check Locking）
        if (instance == nullptr)
        {
            lock_guard<mutex> lock(mtx); // 线程锁
            if (instance == nullptr)
            {
                instance = new Singleton();
            }
        }
        return instance;
    }

    void show()
    {
        cout << "这是 Singleton 实例" << endl;
    }
};

// 初始化静态成员
Singleton* Singleton::instance = nullptr;
mutex Singleton::mtx;

// 测试
int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();

    s1->show();

    if (s1 == s2)
        cout << "两个实例相同，单例模式生效！" << endl;

    return 0;
}

注意：

• = delete 是 C++11 引入的一种机制，用来显式标记某个函数（包括构造、赋值、析构、普通函数）不允许使用。
• 如果调用被 = delete 的函数，编译时就会报错，这比写成私有函数 + 空实现更安全、更清晰。

5. 变体说明

五、工厂模式（Factory Pattern）

1. 概念

工厂模式是一种常见的创建型设计模式，核心目的是：

将对象的创建逻辑从使用者中解耦，由“工厂”统一创建对象。

2. 主要分类

3. 适用场景

• 对象创建过程复杂或变化频繁；
• 代码中存在大量 new 操作，难以维护；
• 系统要根据不同条件动态决定创建哪一类对象。

4. 示例——工厂方法模式（Factory Method Pattern）

场景：不同的图形类（Circle, Rectangle），由对应的工厂类生成。

产品抽象类：

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
    virtual ~Shape() = default;
};

具体产品类：

class Circle : public Shape {
public:
    void draw() override 
    {
        std::cout << "绘制圆形" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override 
    {
        std::cout << "绘制矩形" << std::endl;
    }
};

工厂抽象类：

class ShapeFactory {
public:
    virtual Shape* createShape() = 0; // 创建产品接口
    virtual ~ShapeFactory() = default;
};

具体工厂类：

class CircleFactory : public ShapeFactory {
public:
    Shape* createShape() override 
    {
        return new Circle();
    }
};

class RectangleFactory : public ShapeFactory {
public:
    Shape* createShape() override 
    {
        return new Rectangle();
    }
};

客户端使用：

int main() {
    ShapeFactory* factory;

    factory = new CircleFactory();
    Shape* circle = factory->createShape();
    circle->draw();
    delete circle;
    delete factory;

    factory = new RectangleFactory();
    Shape* rectangle = factory->createShape();
    rectangle->draw();
    delete rectangle;
    delete factory;

    return 0;
}

5. 优缺点分析

六、观察者模式（Observer Pattern）

1. 概念

观察者模式是一种行为型模式，用于建立一种一对多的依赖关系：

当一个对象（主题/被观察者）的状态发生变化时，所有依赖于它的对象（观察者）都会自动收到通知并更新。

2. 应用场景

3. 结构组成

4. C++ 示例代码

场景：气象站（WeatherStation）数据变化，通知多个显示设备（观察者）。

抽象观察者接口：

class Observer {
public:
    virtual void update(float temperature) = 0;
    virtual ~Observer() = default;
};

主题（Subject）接口：

#include <vector>

class Subject {
public:
    virtual void attach(Observer* observer) = 0;
    virtual void detach(Observer* observer) = 0;
    virtual void notify() = 0;
    virtual ~Subject() = default;
};

具体主题类：

class WeatherStation : public Subject {
private:
    std::vector<Observer*> observers;
    float temperature;

public:
    void setTemperature(float temp) 
    {
        temperature = temp;
        notify(); // 数据变化时，通知所有观察者
    }

    void attach(Observer* observer) override 
    {
        observers.push_back(observer);
    }

    void detach(Observer* observer) override 
    {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notify() override {
        for (Observer* o : observers) 
        {
            o->update(temperature);
        }
    }
};

具体观察者类：

class PhoneDisplay : public Observer {
public:
    void update(float temperature) override 
    {
        std::cout << "[Phone] 当前温度：" << temperature << "°C" << std::endl;
    }
};

class LEDDisplay : public Observer {
public:
    void update(float temperature) override 
    {
        std::cout << "[LED] 显示屏温度：" << temperature << "°C" << std::endl;
    }
};

客户端使用：

int main() {
    WeatherStation station;

    PhoneDisplay phone;
    LEDDisplay led;

    station.attach(&phone);
    station.attach(&led);

    station.setTemperature(25.5f);
    station.setTemperature(30.2f);

    return 0;
}

5. 优缺点分析

6. 实际应用

• Qt 信号槽机制；
• GUI 框架（按钮监听器）；
• 消息发布/订阅（如 Kafka、RabbitMQ）；
• Excel 单元格间依赖（值变化时联动）。

七、代理模式（Proxy Pattern）

1. 概念

代理模式属于结构型设计模式，主要作用是：

为其他对象提供一种“代理”以控制对该对象的访问。

即通过一个中介（代理对象）来间接访问目标对象，可以增加访问控制、延迟加载、资源控制等功能。

2. 适用场景

3. 结构角色

4. C++ 示例——访问图像的代理模式（虚拟代理）

抽象接口（Subject）：

class Image {
public:
    virtual void display() = 0;
    virtual ~Image() = default;
};

真实对象（RealSubject）：

class RealImage : public Image {
private:
    std::string filename;
public:
    RealImage(const std::string& file) : filename(file) 
    {
        loadFromDisk();
    }

    void loadFromDisk() 
    {
        std::cout << "加载图片文件：" << filename << std::endl;
    }

    void display() override 
    {
        std::cout << "显示图片：" << filename << std::endl;
    }
};

代理对象（Proxy）：

class ProxyImage : public Image {
private:
    std::string filename;
    RealImage* realImage = nullptr;
public:
    ProxyImage(const std::string& file) : filename(file) {}

    void display() override 
    {
        if (!realImage) 
        {
            realImage = new RealImage(filename); // 延迟加载
        }
        realImage->display();
    }

    ~ProxyImage() 
    {
        delete realImage;
    }
};

客户端使用：

int main() {
    Image* image = new ProxyImage("photo.jpg");

    std::cout << "第一次调用 display() ：" << std::endl;
    image->display();  // 会加载 + 显示

    std::cout << "第二次调用 display() ：" << std::endl;
    image->display();  // 直接显示，不再加载

    delete image;
    return 0;
}

5. 优缺点分析

6. 实际应用

• 虚拟代理：大型图像延迟加载（如网页图片懒加载）；
• 安全代理：数据库连接权限控制；
• 智能代理：引用计数类（如智能指针 std::shared_ptr）；
• 远程代理：RPC、gRPC 框架中的远程服务调用。

八、策略模式（Strategy Pattern）

1. 概念

策略模式是一种典型的行为型设计模式，用于：

将一系列可互换的算法（或策略）封装起来，使它们可以独立于使用它们的客户端自由切换。

2. 适用场景

3. 结构组成

4. C++ 示例——支付策略（微信、支付宝）

抽象策略类：

class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
    virtual ~PaymentStrategy() = default;
};

具体策略类：

class WeChatPay : public PaymentStrategy {
public:
    void pay(int amount) override 
    {
        std::cout << "使用微信支付：" << amount << " 元" << std::endl;
    }
};

class Alipay : public PaymentStrategy {
public:
    void pay(int amount) override 
    {
        std::cout << "使用支付宝支付：" << amount << " 元" << std::endl;
    }
};

上下文类（使用策略）：

class PaymentContext {
private:
    PaymentStrategy* strategy;

public:
    PaymentContext(PaymentStrategy* strategy) : strategy(strategy) {}

    void setStrategy(PaymentStrategy* newStrategy) 
    {
        strategy = newStrategy;
    }

    void pay(int amount) 
    {
        strategy->pay(amount);
    }
};

客户端使用示例：

int main() {
    WeChatPay wechat;
    Alipay alipay;

    PaymentContext context(&wechat);
    context.pay(100); // 使用微信支付

    context.setStrategy(&alipay);
    context.pay(200); // 使用支付宝支付

    return 0;
}

5. 优缺点分析

6. 现实应用

• 排序器中选择不同排序策略（快速排序、归并排序等）；
• 游戏中角色选择攻击行为（近战、远程、魔法）；
• 视频播放器根据网络状况切换清晰度策略。

九、装饰器模式（Decorator Pattern）

1. 概念

装饰器模式（Decorator）是一种结构型设计模式，用于：

在不改变原始类代码的前提下，动态地为对象添加额外的功能。

2. 使用场景

3. 结构角色

4. C++ 示例——饮料加调料系统

抽象组件接口（Component）：

class Beverage {
public:
    virtual std::string getDescription() = 0;
    virtual double cost() = 0;
    virtual ~Beverage() = default;
};

具体组件（ConcreteComponent）：

class Coffee : public Beverage {
public:
    std::string getDescription() override 
    {
        return "Coffee";
    }

    double cost() override 
    {
        return 5.0;
    }
};

抽象装饰器（Decorator）：

class CondimentDecorator : public Beverage {
protected:
    Beverage* beverage;
public:
    CondimentDecorator(Beverage* b) : beverage(b) {}
};

具体装饰器（ConcreteDecorator）：

class Milk : public CondimentDecorator {
public:
    Milk(Beverage* b) : CondimentDecorator(b) {}

    std::string getDescription() override 
    {
        return beverage->getDescription() + ", Milk";
    }

    double cost() override 
    {
        return beverage->cost() + 1.5;
    }
};

class Sugar : public CondimentDecorator {
public:
    Sugar(Beverage* b) : CondimentDecorator(b) {}

    std::string getDescription() override 
    {
        return beverage->getDescription() + ", Sugar";
    }

    double cost() override 
    {
        return beverage->cost() + 0.5;
    }
};

客户端使用：

int main() {
    Beverage* beverage = new Coffee();                  // 基础咖啡
    beverage = new Milk(beverage);                     // 加牛奶
    beverage = new Sugar(beverage);                    // 加糖

    std::cout << "饮料描述: " << beverage->getDescription() << std::endl;
    std::cout << "总价: " << beverage->cost() << " 元" << std::endl;

    delete beverage; // 实际应逐层释放
    return 0;
}

5. 优缺点分析

6. 现实应用

• Java I/O 流（BufferedInputStream, DataInputStream 等）；
• 图形组件样式叠加（边框、阴影、背景）；
• 日志增强、权限控制模块；
• C++ 中的流操作符（如 std::ostream 装饰行为），

十、常用设计模式的比较

使用建议：

• 要 控制对象数量 → 单例模式；
• 要 封装对象创建逻辑 → 工厂模式；
• 要 对象间解耦并实时通知 → 观察者模式；
• 要 算法/行为灵活切换 → 策略模式；
• 要 控制对象访问/增强功能 → 代理模式；
• 要 在不改变原对象的基础上扩展功能 → 装饰器模式。