创建型设计模式

创建型设计模式主要处理对象的创建机制，试图以适合当前情况的方式创建对象。以下是五种主要的创建型模式及其角色关系图和C++实现示例。

1. 单例模式 (Singleton Pattern)

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

角色关系图

[Client] --> [Singleton]
    |
    |-- getInstance()
    |-- otherOperation()

C++ 实现

#include <iostream>
#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mtx;
    
    // 私有构造函数防止外部实例化
    Singleton() {}
    
public:
    // 删除拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mtx);
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
    
    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }
};

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

int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    
    std::cout << "s1 address: " << s1 << std::endl;
    std::cout << "s2 address: " << s2 << std::endl; // 输出相同地址
    
    s1->doSomething();
    
    return 0;
}

2. 工厂方法模式 (Factory Method Pattern)

目的：定义一个创建对象的接口，但让子类决定实例化哪个类。

角色关系图

[Creator] <|-- [ConcreteCreator]
    |          |
    |          |-- factoryMethod()
    |-- otherOperation()
    
[Product] <|-- [ConcreteProduct]

C++ 实现

#include <iostream>
#include <memory>

// 产品接口
class Product {
public:
    virtual ~Product() {}
    virtual void operation() = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation" << std::endl;
    }
};

// 创建者抽象类
class Creator {
public:
    virtual ~Creator() {}
    virtual std::unique_ptr<Product> factoryMethod() = 0;
    
    void someOperation() {
        auto product = factoryMethod();
        product->operation();
    }
};

// 具体创建者A
class ConcreteCreatorA : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() override {
        return std::make_unique<ConcreteProductA>();
    }
};

// 具体创建者B
class ConcreteCreatorB : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    std::unique_ptr<Creator> creatorA = std::make_unique<ConcreteCreatorA>();
    creatorA->someOperation();
    
    std::unique_ptr<Creator> creatorB = std::make_unique<ConcreteCreatorB>();
    creatorB->someOperation();
    
    return 0;
}

3. 抽象工厂模式 (Abstract Factory Pattern)

目的：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

角色关系图

[AbstractFactory] <|-- [ConcreteFactory1]
    |                  [ConcreteFactory2]
    |
    |-- createProductA()
    |-- createProductB()
    
[AbstractProductA] <|-- [ProductA1]
    |                  [ProductA2]
    
[AbstractProductB] <|-- [ProductB1]
                       [ProductB2]

C++ 实现

#include <iostream>
#include <memory>

// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() {}
    virtual void operationA() = 0;
};

// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ProductA1 operation" << std::endl;
    }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ProductA2 operation" << std::endl;
    }
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() {}
    virtual void operationB() = 0;
};

// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ProductB1 operation" << std::endl;
    }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ProductB2 operation" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA1>();
    }
    
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB1>();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA2>();
    }
    
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB2>();
    }
};

int main() {
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
    auto productA1 = factory1->createProductA();
    auto productB1 = factory1->createProductB();
    productA1->operationA();
    productB1->operationB();
    
    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
    auto productA2 = factory2->createProductA();
    auto productB2 = factory2->createProductB();
    productA2->operationA();
    productB2->operationB();
    
    return 0;
}

4. 建造者模式 (Builder Pattern)

目的：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

角色关系图

[Director] --> [Builder]
    |
    |-- construct()
    
[Builder] <|-- [ConcreteBuilder]
    |           |
    |           |-- buildPart()
    |-- getResult()
    
[Product]

C++ 实现

#include <iostream>
#include <memory>
#include <string>
#include <vector>

// 产品类
class Product {
private:
    std::vector<std::string> parts;
    
public:
    void addPart(const std::string& part) {
        parts.push_back(part);
    }
    
    void show() const {
        std::cout << "Product parts: " << std::endl;
        for (const auto& part : parts) {
            std::cout << "- " << part << std::endl;
        }
    }
};

// 抽象建造者
class Builder {
public:
    virtual ~Builder() {}
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual void buildPartC() = 0;
    virtual std::unique_ptr<Product> getResult() = 0;
};

// 具体建造者
class ConcreteBuilder : public Builder {
private:
    std::unique_ptr<Product> product;
    
public:
    ConcreteBuilder() : product(std::make_unique<Product>()) {}
    
    void buildPartA() override {
        product->addPart("Part A");
    }
    
    void buildPartB() override {
        product->addPart("Part B");
    }
    
    void buildPartC() override {
        product->addPart("Part C");
    }
    
    std::unique_ptr<Product> getResult() override {
        return std::move(product);
    }
};

// 指挥者
class Director {
public:
    void construct(Builder& builder) {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
};

int main() {
    ConcreteBuilder builder;
    Director director;
    
    director.construct(builder);
    auto product = builder.getResult();
    product->show();
    
    return 0;
}

5. 原型模式 (Prototype Pattern)

目的：通过复制现有对象来创建新对象，而不是新建。

角色关系图

[Client] --> [Prototype]
    |
    |-- clone()
    
[Prototype] <|-- [ConcretePrototype]

C++ 实现

#include <iostream>
#include <memory>
#include <string>

// 原型接口
class Prototype {
public:
    virtual ~Prototype() {}
    virtual std::unique_ptr<Prototype> clone() const = 0;
    virtual void printInfo() const = 0;
    virtual void setValue(int value) = 0;
};

// 具体原型
class ConcretePrototype : public Prototype {
private:
    int value;
    std::string name;
    
public:
    ConcretePrototype(int val, const std::string& n) : value(val), name(n) {}
    
    std::unique_ptr<Prototype> clone() const override {
        return std::make_unique<ConcretePrototype>(*this);
    }
    
    void printInfo() const override {
        std::cout << "ConcretePrototype: " << name << ", value = " << value << std::endl;
    }
    
    void setValue(int val) override {
        value = val;
    }
};

int main() {
    std::unique_ptr<Prototype> original = std::make_unique<ConcretePrototype>(10, "Original");
    std::cout << "Original: ";
    original->printInfo();
    
    // 克隆对象
    std::unique_ptr<Prototype> clone = original->clone();
    clone->setValue(20);
    
    std::cout << "Clone: ";
    clone->printInfo();
    
    std::cout << "Original after cloning: ";
    original->printInfo(); // 原始对象不受影响
    
    return 0;
}

以上是五种主要的创建型设计模式的C++实现示例。