C++四大设计模式：单例、工厂、观察者、策略

引言

在前面的文章中，我们学习了 C++ 语法、STL、数据结构。这些都是"怎么写代码"的工具。而设计模式解决的是更高层次的问题——"代码怎么组织才更好"。

设计模式是前辈们总结的、经过反复验证的代码组织方案。它不是凭空发明的，而是在无数项目中"踩坑"后提炼出的最佳实践。掌握设计模式，能让你写出更易维护、更易扩展、更易复用的代码。

本文聚焦 C++ 中最常用的四种设计模式：单例模式、工厂模式、观察者模式和策略模式。

第一部分：单例模式

一、什么是单例模式

保证一个类只有一个实例，并提供全局访问点。比如程序的配置管理器、日志系统、数据库连接池——这些东西整个程序只需要一份。

二、懒汉式（用到才创建）

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

class Singleton {
private:
static Singleton* instance;
static mutex mtx;

// 构造函数私有！外部不能 new
Singleton() { cout << "单例创建" << endl; }

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

public:
// 全局访问点（线程安全）
static Singleton* getInstance() {
if (instance == nullptr) {
lock_guard<mutex> lock(mtx); // 加锁
if (instance == nullptr) { // 双重检查
instance = new Singleton();
}
}
return instance;
}

void doSomething() { cout << "工作" << endl; }
};

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

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

cout << (s1 == s2) << endl; // 1（同一个对象）
// Singleton s3; // 错误！构造私有
}

为什么用双重检查锁？

三、C++11 最简写法（推荐）

C++11 保证了静态局部变量的线程安全，一行搞定：

class Singleton {
private:
Singleton() = default;
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;

public:
static Singleton& getInstance() {
static Singleton instance; // C++11 保证线程安全！
return instance;
}
};

第二部分：工厂模式

一、简单工厂

把对象的创建逻辑集中到一个工厂类中，调用者不需要知道具体怎么创建。

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

// 产品基类
class Animal {
public:
virtual void speak() = 0;
virtual ~Animal() = default;
};

// 具体产品
class Dog : public Animal {
public:
void speak() override { cout << "汪汪" << endl; }
};

class Cat : public Animal {
public:
void speak() override { cout << "喵喵" << endl; }
};

// 简单工厂
class AnimalFactory {
public:
static Animal* createAnimal(const string& type) {
if (type == "dog") return new Dog();
if (type == "cat") return new Cat();
return nullptr;
}
};

int main() {
Animal* dog = AnimalFactory::createAnimal("dog");
dog->speak(); // 汪汪

Animal* cat = AnimalFactory::createAnimal("cat");
cat->speak(); // 喵喵

delete dog;
delete cat;
}

二、工厂方法模式

每个具体产品对应一个具体工厂，新增产品时不修改已有代码（开闭原则）。

// 抽象工厂
class AnimalFactory {
public:
virtual Animal* createAnimal() = 0;
virtual ~AnimalFactory() = default;
};

// 具体工厂
class DogFactory : public AnimalFactory {
public:
Animal* createAnimal() override { return new Dog(); }
};

class CatFactory : public AnimalFactory {
public:
Animal* createAnimal() override { return new Cat(); }
};

int main() {
DogFactory dogFactory;
Animal* dog = dogFactory.createAnimal();
dog->speak(); // 汪汪

CatFactory catFactory;
Animal* cat = catFactory.createAnimal();
cat->speak(); // 喵喵

delete dog;
delete cat;
}

第三部分：观察者模式

定义一对多依赖关系，当被观察者状态变化时，自动通知所有观察者。比如 GUI 的事件监听、消息订阅通知。

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

// 观察者接口
class Observer {
public:
virtual void update(const string& message) = 0;
virtual ~Observer() = default;
};

// 被观察者
class Subject {
private:
vector<Observer*> observers;
string state;
public:
// 注册观察者
void attach(Observer* obs) {
observers.push_back(obs);
}

// 移除观察者
void detach(Observer* obs) {
observers.erase(
remove(observers.begin(), observers.end(), obs),
observers.end()
);
}

// 通知所有观察者
void notify() {
for (auto* obs : observers) {
obs->update(state);
}
}

// 改变状态并通知
void setState(const string& newState) {
state = newState;
notify(); // 状态一改变就通知
}
};

// 具体观察者
class User : public Observer {
private:
string name;
public:
User(const string& name) : name(name) {}

void update(const string& message) override {
cout << name << " 收到通知：" << message << endl;
}
};

int main() {
Subject subject;

User alice("Alice");
User bob("Bob");

subject.attach(&alice);
subject.attach(&bob);

subject.setState("新版本发布了！");
// Alice 收到通知：新版本发布了！
// Bob 收到通知：新版本发布了！

subject.detach(&bob);
subject.setState("服务器维护中…");
// Alice 收到通知：服务器维护中…
// （Bob 已取消订阅，不会收到）
}

第四部分：策略模式

定义一系列算法，把它们封装起来，让它们可以互相替换。比如排序可以选快排、归并；支付可以选微信、支付宝。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 策略接口
class SortStrategy {
public:
virtual void sort(vector<int>& data) = 0;
virtual ~SortStrategy() = default;
};

// 具体策略：升序
class AscendingSort : public SortStrategy {
public:
void sort(vector<int>& data) override {
std::sort(data.begin(), data.end());
}
};

// 具体策略：降序
class DescendingSort : public SortStrategy {
public:
void sort(vector<int>& data) override {
std::sort(data.begin(), data.end(), greater<int>());
}
};

// 使用策略的类
class DataProcessor {
private:
SortStrategy* strategy;
public:
void setStrategy(SortStrategy* s) { strategy = s; }

void process(vector<int>& data) {
if (strategy) {
strategy->sort(data);
}
}
};

int main() {
vector<int> data = {5, 2, 8, 1, 9};
DataProcessor processor;

AscendingSort asc;
DescendingSort desc;

// 用升序策略
processor.setStrategy(&asc);
processor.process(data); // 1 2 5 8 9

// 切换到降序策略
processor.setStrategy(&desc);
processor.process(data); // 9 8 5 2 1
}

策略模式的核心：用组合代替继承，算法可以在运行时灵活切换，不需要改代码。

总结

一、四种模式速查

二、一句话记忆

单例构造私有化保证全局唯一，工厂把创建和使用分离，观察者实现一对多自动通知，策略让算法可以随时替换——四大模式都是为了让代码更灵活、更好改、更好测。