在C++中，设计模式（Design Patterns）是用于解决在软件设计中经常遇到的一些通用问题的最佳实践。这些设计模式是在多年的软件开发过程中积累下来的经验和智慧的结晶。它们可以帮助开发者设计出更加灵活、可维护、可扩展的软件系统。以下是一些在C++中常用的设计模式，详细见22种设计模式。
1、单例模式（Singleton Pattern）：
确保一个类只有一个实例，并提供一个全局访问点。
class Singleton {
private:
static Singleton* instance;
Singleton() {}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
public:
static Singleton* getInstance() {
if (!instance) {
instance = new Singleton();
}
return instance;
}
// ... 其他成员函数 ...
};
Singleton* Singleton::instance = nullptr;注意：上述这种写法并非线程安全的，为了保证单例的线程安全，有以下几种方式：
饿汉式（立即初始化）：
class Singleton {
public:
static Singleton& getInstance() {
return instance;
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
Singleton() {}
static Singleton instance; // 静态局部变量，在类加载时初始化
};
Singleton Singleton::instance; // 静态成员变量在类外初始化懒汉式（双重检查锁）：
class Singleton {
public:
static Singleton& getInstance() {
if (instance == nullptr) { // 第一次检查
std::lock_guard<std::mutex> lock(mutex); // 加锁
if (instance == nullptr) { // 第二次检查
instance = new Singleton();
}
}
return *instance;
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
Singleton() {}
static Singleton* instance;
static std::mutex mutex; // 用于同步的互斥量
};
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;静态内部类（C++11以后推荐）：
class Singleton {
public:
static Singleton& getInstance() {
return SingletonHolder::instance;
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
Singleton() {}
struct SingletonHolder {
static Singleton instance;
};
static SingletonHolder holder; // 静态成员变量，保证在第一次调用getInstance时初始化
};
Singleton::SingletonHolder Singleton::holder; // 静态成员变量在类外初始化
Singleton Singleton::SingletonHolder::instance; // 静态局部对象，在holder初始化时初始化2、工厂模式（Factory Pattern）：
用于封装对象的创建过程，隐藏创建细节，使得代码更加灵活和可扩展。工厂模式主要分三种：简单工厂模式、工厂方法模式和抽象工厂模式。
简单工厂模式：
// 产品接口
class Product {
public:
virtual ~Product() {}
virtual void use() = 0;
};
// 产品实现
class ProductA : public Product {
public:
void use() override {
std::cout << "Using ProductA" << std::endl;
}
};
class ProductB : public Product {
public:
void use() override {
std::cout << "Using ProductB" << std::endl;
}
};
// 简单工厂类
class SimpleFactory {
public:
static Product* createProduct(const std::string& type) {
if (type == "A") {
return new ProductA();
} else if (type == "B") {
return new ProductB();
}
return nullptr;
}
};
// 客户端代码
int main() {
Product* productA = SimpleFactory::createProduct("A");
if (productA) {
productA->use();
delete productA;
}
Product* productB = SimpleFactory::createProduct("B");
if (productB) {
productB->use();
delete productB;
}
return 0;
}工厂方法模式：
// 产品接口
class Product {
public:
virtual ~Product() {}
virtual void use() = 0;
};
// 产品实现
class ProductA : public Product {
public:
void use() override {
std::cout << "Using ProductA" << std::endl;
}
};
class ProductB : public Product {
public:
void use() override {
std::cout << "Using ProductB" << std::endl;
}
};
// 工厂接口
class Creator {
public:
virtual ~Creator() {}
virtual Product* createProduct() = 0;
};
// 工厂实现
class CreatorA : public Creator {
public:
Product* createProduct() override {
return new ProductA();
}
};
class CreatorB : public Creator {
public:
Product* createProduct() override {
return new ProductB();
}
};
// 客户端代码
int main() {
Creator* creatorA = new CreatorA();
Product* productA = creatorA->createProduct();
productA->use();
delete productA;
delete creatorA;
Creator* creatorB = new CreatorB();
Product* productB = creatorB->createProduct();
productB->use();
delete productB;
delete creatorB;
return 0;
}抽象工厂模式：
// 产品接口
class ProductA {
public:
virtual ~ProductA() {}
virtual void use() = 0;
};
class ProductB {
public:
virtual ~ProductB() {}
virtual void use() = 0;
};
// 产品实现
class ProductA1 : public ProductA {
public:
void use() override {
std::cout << "Using ProductA1" << std::endl;
}
};
class ProductB1 : public ProductB {
public:
void use() override {
std::cout << "Using ProductB1" << std::endl;
}
};
// 抽象工厂接口
class AbstractFactory {
public:
virtual ~AbstractFactory() {}
virtual ProductA* createProductA() = 0;
virtual ProductB* createProductB() = 0;
};
// 工厂实现
class Factory1 : public AbstractFactory {
public:
ProductA* createProductA() override {
return new ProductA1();
}
ProductB* createProductB() override {
return new ProductB1();
}
};
// 客户端代码
int main() {
AbstractFactory* factory = new Factory1();
ProductA* productA = factory->createProductA();
ProductB* productB = factory->createProductB();
productA->use();
productB->use();3、观察者模式（Observer Pattern）：
定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象状态发生改变时，它的所有依赖者（观察者）都会自动收到通知并更新。
class Subject {
// ...
std::list<Observer*> observers;
void notify() {
for (auto observer : observers) {
observer->update();
}
}
// ...
};
class Observer {
public:
virtual void update() = 0;
// ...
};4、建造者模式（Builder Pattern）：
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
class Builder {
public:
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
// ...
virtual Product* getResult() = 0;
};
class ConcreteBuilder : public Builder {
Product* product;
// 实现构建过程
// ...
};
class Director {
public:
void construct(Builder* builder) {
builder->buildPartA();
builder->buildPartB();
// ...
}
};5、原型模式（Prototype Pattern）：
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
class Prototype {
public:
virtual Prototype* clone() = 0;
// ...
};
class ConcretePrototype : public Prototype {
public:
ConcretePrototype* clone() override {
return new ConcretePrototype(*this); // 拷贝构造函数实现克隆
}
// ...
};6、适配器模式（Adapter Pattern）：
将一个类的接口转换成客户端所期望的另一种接口，从而使得原本由于接口不兼容而无法一起工作的类能够一起工作。
7、迭代器模式（Iterator Pattern）：
提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
8、组合模式（Composite Pattern）：
将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
9、模板方法模式（Template Method Pattern）：
定义一个操作中的算法的框架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。
10、策略模式（Strategy Pattern）：
定义了一系列的算法，并将每一个算法封装起来，使它们可以互相替换。策略模式使得算法可以独立于使用它的客户端变化。
以上只是设计模式中的一部分，还有其他许多设计模式可以在C++中使用。学习和理解这些设计模式可以帮助你更好地设计出高质量的软件系统。
