创建型模式（Creational Patterns）关注 对象的创建过程，通过封装实例化逻辑，使系统更灵活地应对变化。
常见的创建型模式包括：
- 单例（Singleton）
- 工厂方法（Factory Method）
- 抽象工厂（Abstract Factory）
- 建造者（Builder）
- 原型（Prototype）
创建型模式详解
1. 单例模式（Singleton）
定义：保证一个类只有一个实例，并提供全局访问点。
场景：
- 日志系统。
- 配置管理器。
- 线程池。
#include <iostream>
class Singleton {
private:
Singleton() { std::cout << "Init\n"; }
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
public:
static Singleton& getInstance() {
static Singleton instance; // C++11 保证线程安全
return instance;
}
};
int main() {
Singleton& s1 = Singleton::getInstance();
Singleton& s2 = Singleton::getInstance();
std::cout << (&s1 == &s2); // 输出 1
}
2. 工厂方法模式（Factory Method）
定义：定义一个创建对象的接口，让子类决定实例化哪一个类。
场景：
- 跨平台 UI 控件。
- 数据库驱动。
#include <iostream>
#include <memory>
class Product {
public:
virtual void use() = 0;
virtual ~Product() = default;
};
class ConcreteProductA : public Product {
public:
void use() override { std::cout << "Use A\n"; }
};
class Factory {
public:
virtual std::unique_ptr<Product> create() = 0;
virtual ~Factory() = default;
};
class FactoryA : public Factory {
public:
std::unique_ptr<Product> create() override {
return std::make_unique<ConcreteProductA>();
}
};
int main() {
FactoryA f;
auto p = f.create();
p->use();
}
3. 抽象工厂模式（Abstract Factory）
定义：提供一个接口，创建一系列相关或依赖对象，而无需指定具体类。
场景：
- 跨平台 GUI（Windows/Linux/Mac）。
- 数据库族（MySQL/Oracle）。
#include <iostream>
#include <memory>
class Button {
public:
virtual void draw() = 0;
virtual ~Button()=default;
};
class WinButton : public Button {
public:
void draw() override { std::cout << "WinButton\n"; }
};
class MacButton : public Button {
public:
void draw() override { std::cout << "MacButton\n"; }
};
class GUIFactory {
public:
virtual std::unique_ptr<Button> createButton() = 0;
virtual ~GUIFactory()=default;
};
class WinFactory : public GUIFactory {
public:
std::unique_ptr<Button> createButton() override { return std::make_unique<WinButton>(); }
};
class MacFactory : public GUIFactory {
public:
std::unique_ptr<Button> createButton() override { return std::make_unique<MacButton>(); }
};
int main() {
std::unique_ptr<GUIFactory> f = std::make_unique<WinFactory>();
auto btn = f->createButton();
btn->draw();
}
4. 建造者模式（Builder）
定义：将复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。
场景：
- 游戏角色构建。
- 复杂文档生成器。
#include <iostream>
#include <string>
class Product {
public:
std::string parts;
void show() { std::cout << "Product: " << parts << "\n"; }
};
class Builder {
public:
virtual void buildPartA() = 0;
virtual void buildPartB() = 0;
virtual Product getResult() = 0;
virtual ~Builder()=default;
};
class ConcreteBuilder : public Builder {
Product p;
public:
void buildPartA() override { p.parts += "A "; }
void buildPartB() override { p.parts += "B "; }
Product getResult() override { return p; }
};
class Director {
public:
Product construct(Builder& b) {
b.buildPartA();
b.buildPartB();
return b.getResult();
}
};
int main() {
ConcreteBuilder b;
Director d;
Product p = d.construct(b);
p.show();
}
5. 原型模式（Prototype）
定义：通过复制已有对象来创建新对象。
场景：
- 对象创建成本高（如需要复杂计算、数据库访问、大量参数准备）。
- 需要避免复杂的构造过程，比如在图形编辑器、文档处理器中，经常需要复制已有元素，应用原型模式会更自然。
#include <iostream>
#include <memory>
class Prototype {
public:
virtual std::unique_ptr<Prototype> clone() = 0;
virtual void show() = 0;
virtual ~Prototype() = default;
};
class ConcretePrototype : public Prototype {
int data;
public:
ConcretePrototype(int d):data(d){}
std::unique_ptr<Prototype> clone() override {
return std::make_unique<ConcretePrototype>(*this);
}
void show() override { std::cout << "Data: " << data << "\n"; }
};
int main() {
auto p1 = std::make_unique<ConcretePrototype>(42);
auto p2 = p1->clone();
p2->show();
}
总结
- 单例：全局唯一实例。
- 工厂方法：子类决定实例化。
- 抽象工厂：创建一族相关对象。
- 建造者：分步骤构建复杂对象。
- 原型：通过克隆创建对象。
创建型模式的核心是 将对象的创建过程与使用解耦，从而提升系统的灵活性和可维护性。