C++常用设计模式详解

前言：本文详细解释几种常用的C++设计模式，都是平时项目中用的比较多的。本文针对每种设计模式都给出了示例，让你跟着代码彻底搞懂设计模式。

Tips：如果是准备面试，不需要知道所有的设计模式，要深入理解下面几种常用即可，因为面试官会先问你了解哪些设计模式，然后从你了解的里面挑一个深问，而且很有可能还会让你手撕出来。而且，最好提前准备一下自己的项目中哪里用到了你说的设计模式，面试官也可能会问。

---

C++常用设计模式

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点来访问该实例。主要用于控制全局资源，如日志管理器、线程池、配置管理器等。

实现方式：

• 构造函数为私有，防止外部创建对象。
• 提供一个静态方法，负责创建或获取该类的唯一实例。
• 确保线程安全性。

class Singleton {
private:
    Singleton() {}

public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

    // 禁止拷贝和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

C++11规定了局部静态变量在多线程条件下的初始化行为，要求编译器保证了局部静态变量的线程安全性。这样，只有当第一次访问getInstance()方法时才创建实例。C++11之后该实现是线程安全的，C++11之前仍需加锁。

工厂模式

用于创建对象（产品类）的接口，而不暴露对象创建的具体逻辑。适合于需要创建多个相似对象的场景，比如：图形界面组件、数据库连接。

简单工厂模式

建⽴⼀个⼯⼚类，对实现了同⼀接⼝的⼀些类（产品类）进⾏实例的创建。简单⼯⼚模式的实质是由⼀个⼯⼚类根据传⼊的参数，动态决定应该创建哪⼀个产品类（这些产品类继承⾃⼀个⽗类或接⼝）的实例。

// 产品类（抽象类，不能实例化）
class Product {
public:
    virtual void show() = 0;
};

class ConcreteProductA : public Product {
public:
    void show() override { std::cout << "Product A\n"; }
};

class ConcreteProductB : public Product {
public:
    void show() override { std::cout << "Product B\n"; }
};

// ⼯⼚类
class Factory {
public:
	Product* product(const string str){
		if (str == "productA")
			return new ConcreteProductA();
		if (str == "productB")
			return new ConcreteProductB();
		return nullptr;
	};
};

抽象工厂模式

为了进⼀步解耦，在简单⼯⼚的基础上发展出了抽象⼯⼚模式，即连⼯⼚都抽象出来，实现了进⼀步代码解耦。通过定义一个用于创建对象的接口，让工厂子类决定实例化哪个类。工厂模式的核心思想是将对象的创建和使用分离，以提高灵活性和扩展性。

实现方式：

• 定义一个工厂基类，声明一个创建产品的接口。
• 工厂子类实现这个接口，负责具体产品的创建。

class Product {
public:
    virtual void show() = 0;
};

class ConcreteProductA : public Product {
public:
    void show() override { std::cout << "Product A\n"; }
};

class ConcreteProductB : public Product {
public:
    void show() override { std::cout << "Product B\n"; }
};

class Factory {
public:
    virtual Product* createProduct() = 0;
};

class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

观察者模式

定义了对象之间一对多的依赖关系，让多个观察对象同时监听⼀个被观察对象，被观察对象状态发⽣变化时，会通知所有的观察对象，使他们能够更新⾃⼰的状态。该模式常用于事件驱动系统、消息发布-订阅系统。

观察者模式中存在两种⻆⾊：

• 观察者：内部包含被观察者对象，当被观察者对象的状态发⽣变化时，更新自己的状态。（接收通知更新状态）
• 被观察者：内部包含了所有观察者对象，当状态发⽣变化时通知所有的观察者更新自己的状态。（发送通知）

实现方式：

• 定义一个被观察者（Subject）接口，允许添加、删除观察者。
• 定义观察者接口，声明更新方法。
• 被观察者在状态发生变化时，通知所有观察者调用更新方法。

// 观察者
class Observer {
public:
    virtual void update(int value) = 0;
};

class ConcreteObserver : public Observer {
private:
    int observerValue;
    
public:
	// 被观察者对象的状态发⽣变化时，更新自己的状态
    void update(int value) override {
        observerValue = value;
        std::cout << "Observer value updated to " << observerValue << "\n";
    }
};

// 被观察者
class Subject {
private:
    std::vector<Observer*> observers;	// 存放所有观察者
    int state;

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

    void setState(int value) {
        state = value;
        notify();
    }
	
	// 通知所有的观察者更新自己的状态
    void notify() {
        for (Observer* observer : observers) {
            observer->update(state);
        }
    }
};

装饰器模式

装饰器模式允许向现有对象动态地添加行为，而不影响其他同类对象。该模式通常用于给对象增加功能，同时保持对象的结构灵活可扩展。

实现方式：

• 定义一个组件接口，声明可以被装饰的操作。
• 具体组件类实现接口，执行基本操作。
• 装饰器类持有组件的引用，并在执行基本操作时添加新的功能。

// 组件接口
class Component {
public:
    virtual void operation() = 0;
};

// 具体组件
class ConcreteComponent : public Component {
public:
    void operation() override {
        std::cout << "ConcreteComponent operation\n";
    }
};

// 抽象装饰类
class Decorator : public Component {
protected:
    Component* component;

public:
    Decorator(Component* comp) : component(comp) {}

    void operation() override {
        component->operation();
    }
};

// 具体装饰类
class ConcreteDecorator : public Decorator {
public:
    ConcreteDecorator(Component* comp) : Decorator(comp) {}

    void operation() override {
        Decorator::operation();
        std::cout << "ConcreteDecorator added operation\n";
    }
};

// 创建一个具体组件
Component* component = new ConcreteComponent();
// 装饰组件
Component* decorator = new ConcreteDecorator(component);

解释：通过具体装饰类传入原对象，并重写操作函数 operation() 来实现对象的功能扩展，ConcreteDecorator::operation 先执行对象原操作，再执行新扩展的功能。

策略模式

策略模式定义了一系列算法，将每个算法封装到一个独立的类中，使得它们可以相互替换。此模式允许算法的变化独立于使用它的客户端。常用于：算法选择、支付方式选择等。

实现方式：

• 定义一个抽象策略接口，声明策略的操作。
• 策略实现类负责具体的算法。
• 上下文类负责持有策略并执行操作。

// 抽象策略接口
class Strategy {
public:
    virtual void execute() = 0;
};

// 策略实现类A
class ConcreteStrategyA : public Strategy {
public:
    void execute() override {
        std::cout << "Executing strategy A\n";
    }
};
// 策略实现类B
class ConcreteStrategyB : public Strategy {
public:
    void execute() override {
        std::cout << "Executing strategy B\n";
    }
};

// 上下文类
class Context {
private:
    Strategy* strategy;

public:
    Context(Strategy* strategy) : strategy(strategy) {}
	
	// 选取某种策略
    void setStrategy(Strategy* newStrategy) {
        strategy = newStrategy;
    }
	
	// 执行选取策略的操作
    void executeStrategy() {
        strategy->execute();
    }
};

代理模式

代理模式为其他对象提供一个代理，以控制对这个对象的访问。常见的应用场景包括虚拟代理（延迟加载）、远程代理（为远程对象提供本地代理），以及保护代理（控制对象的访问权限）。

实现方式：

• 定义一个接口，声明需要被代理的操作。
• 代理类实现接口，负责控制实际对象的访问。
• 实际对象类实现接口，执行具体操作。

class Subject {
public:
    virtual void request() = 0;
};

// 实际对象类
class RealSubject : public Subject {
public:
    void request() override {
        std::cout << "RealSubject handling request\n";
    }
};

// 代理类
class Proxy : public Subject {
private:
    RealSubject* realSubject;

public:
    Proxy() : realSubject(nullptr) {}

    ~Proxy() {
        delete realSubject;
    }

    void request() override {
        if (!realSubject) {
            realSubject = new RealSubject();
        }
        std::cout << "Proxy handling request, forwarding to RealSubject...\n";
        realSubject->request();
    }
};