C++设计模式之创建型模式

C++设计模式的创建型模式可以分为单例模型、简单工厂模式、工厂方法模式、抽象工厂模式、原型模式、建造者模式。

1、单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个访问它的全局访问点。例如，在一个多线程程序中，使用单例模式可以确保只有一个线程访问某个资源。

class Singleton {
private:
    static Singleton* instance;
    
    // 私有构造函数，防止外部创建实例
    Singleton() {}
    
public:
    // 获取单例实例的静态方法
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
    
    // 其他成员函数
    void doSomething() {
        // 实现单例类的功能
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;

// 在需要使用单例的地方调用getInstance()方法获取实例
Singleton* singleton = Singleton::getInstance();
singleton->doSomething();

2、简单工厂模式：

以下代码实现了简单工厂模式，其中包含三个类：抽象产品类 Product、具体产品类 ProductA 和 ProductB，以及工厂类 Factory。

在工厂类中，通过 createProduct 方法根据传入的参数类型创建对应的产品对象。而在客户端代码中，只需要调用工厂类的 createProduct 方法即可得到所需的产品对象，无需关心具体的产品创建过程。

这种方式可以方便地扩展新的产品类，同时也避免了客户端代码与具体产品类之间的耦合。但是也有一定的缺点，例如增加新的产品需要修改工厂类的代码，而且如果产品种类过多，工厂类也会变得臃肿。

#include <iostream>
#include <string>

using namespace std;

// 定义抽象产品类
class Product {
public:
    virtual void use() = 0;
};

// 定义具体产品类 A
class ProductA : public Product {
public:
    void use() override {
        cout << "使用产品 A" << endl;
    }
};

// 定义具体产品类 B
class ProductB : public Product {
public:
    void use() override {
        cout << "使用产品 B" << endl;
    }
};

// 定义工厂类
class Factory {
public:
    static Product* createProduct(char type) {
        Product* product = nullptr;
        switch (type) {
            case 'A':
                product = new ProductA();
                break;
            case 'B':
                product = new ProductB();
                break;
            default:
                break;
        }
        return product;
    }
};

int main() {
    // 创建产品 A
    Product* productA = Factory::createProduct('A');
    productA->use();

    // 创建产品 B
    Product* productB = Factory::createProduct('B');
    productB->use();

    // 释放内存
    delete productA;
    delete productB;

    return 0;
}

3、工厂方法模式（Factory Method Pattern）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。例如，一个汽车制造厂可以定义一个工厂接口，让不同的子类工厂来创建不同型号的汽车。

#include <iostream>
#include <string>

using namespace std;

// 定义抽象产品类
class Product {
public:
    virtual void use() = 0;
};

// 定义具体产品类 A
class ProductA : public Product {
public:
    void use() override {
        cout << "使用产品 A" << endl;
    }
};

// 定义具体产品类 B
class ProductB : public Product {
public:
    void use() override {
        cout << "使用产品 B" << endl;
    }
};

// 定义抽象工厂类
class Factory {
public:
    virtual Product* createProduct() = 0;
};

// 定义具体工厂类 A
class FactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ProductA();
    }
};

// 定义具体工厂类 B
class FactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ProductB();
    }
};

int main() {
    // 创建工厂 A 和产品 A
    Factory* factoryA = new FactoryA();
    Product* productA = factoryA->createProduct();
    productA->use();

    // 创建工厂 B 和产品 B
    Factory* factoryB = new FactoryB();
    Product* productB = factoryB->createProduct();
    productB->use();

    // 释放内存
    delete factoryA;
    delete factoryB;
    delete productA;
    delete productB;

    return 0;
}

4、抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。例如，一个家具生产商可以定义一个抽象工厂接口，让不同的子类工厂来创建不同种类的家具。

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

// 具体产品A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void operationA() override {
        // 实现具体产品A1的操作
    }
};

// 具体产品A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void operationA() override {
        // 实现具体产品A2的操作
    }
};

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

// 具体产品B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void operationB() override {
        // 实现具体产品B1的操作
    }
};

// 具体产品B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void operationB() override {
        // 实现具体产品B2的操作
    }
};

// 抽象工厂接口
class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

// 具体工厂1，创建产品族1的产品
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA1();
    }

    AbstractProductB* createProductB() override {
        return new ConcreteProductB1();
    }
};

// 具体工厂2，创建产品族2的产品
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA2();
    }

    AbstractProductB* createProductB() override {
        return new ConcreteProductB2();
    }
};

5、原型模式（Prototype Pattern）：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。例如，在游戏开发中，可以使用原型模式来创建多个相似的游戏角色。

#include <iostream>
#include <string>

using namespace std;

// 定义抽象原型类
class Prototype {
public:
    virtual Prototype* clone() = 0;
};

// 定义具体原型类 A
class ConcretePrototypeA : public Prototype {
public:
    Prototype* clone() override {
        return new ConcretePrototypeA(*this);
    }
};

// 定义具体原型类 B
class ConcretePrototypeB : public Prototype {
public:
    Prototype* clone() override {
        return new ConcretePrototypeB(*this);
    }
};

int main() {
    // 创建原型 A，并克隆出新对象
    Prototype* prototypeA = new ConcretePrototypeA();
    Prototype* cloneA = prototypeA->clone();

    // 创建原型 B，并克隆出新对象
    Prototype* prototypeB = new ConcretePrototypeB();
    Prototype* cloneB = prototypeB->clone();

    // 释放内存
    delete prototypeA;
    delete prototypeB;
    delete cloneA;
    delete cloneB;

    return 0;
}

6、建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。例如，一个房屋建造公司可以定义一个建造者接口，让不同的子类建造者来创建不同类型的房屋。

#include <iostream>
#include <string>

using namespace std;

// 定义产品类
class Product {
public:
    void setPartA(const string& partA) {
        this->partA = partA;
    }

    void setPartB(const string& partB) {
        this->partB = partB;
    }

    void setPartC(const string& partC) {
        this->partC = partC;
    }

    void show() {
        cout << "部件A: " << partA << endl;
        cout << "部件B: " << partB << endl;
        cout << "部件C: " << partC << endl;
    }

private:
    string partA;
    string partB;
    string partC;
};

// 定义抽象建造者类
class Builder {
public:
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual void buildPartC() = 0;
    virtual Product* getResult() = 0;
};

// 定义具体建造者类 A
class ConcreteBuilderA : public Builder {
public:
    void buildPartA() override {
        product->setPartA("Part A - Builder A");
    }

    void buildPartB() override {
        product->setPartB("Part B - Builder A");
    }

    void buildPartC() override {
        product->setPartC("Part C - Builder A");
    }

    Product* getResult() override {
        return product;
    }

private:
    Product* product = new Product();
};

// 定义具体建造者类 B
class ConcreteBuilderB : public Builder {
public:
    void buildPartA() override {
        product->setPartA("Part A - Builder B");
    }

    void buildPartB() override {
        product->setPartB("Part B - Builder B");
    }

    void buildPartC() override {
        product->setPartC("Part C - Builder B");
    }

    Product* getResult() override {
        return product;
    }

private:
    Product* product = new Product();
};

// 定义指挥者类
class Director {
public:
    void construct(Builder* builder) {
        builder->buildPartA();
        builder->buildPartB();
        builder->buildPartC();
    }
};

int main() {
    // 使用建造者 A 构建产品
    Builder* builderA = new ConcreteBuilderA();
    Director directorA;
    directorA.construct(builderA);
    Product* productA = builderA->getResult();
    productA->show();

    // 使用建造者 B 构建产品
    Builder* builderB = new ConcreteBuilderB();
    Director directorB;
    directorB.construct(builderB);
    Product* productB = builderB->getResult();
    productB->show();

    // 释放内存
    delete builderA;
    delete builderB;
    delete productA;
    delete productB;

    return 0;
}

以上代码实现了建造者模式，其中包含六个类：产品类 Product、抽象建造者类 Builder、具体建造者类 ConcreteBuilderA 和 ConcreteBuilderB、指挥者类 Director。

在建造者模式中，产品的构建过程被封装在具体的建造者类中，而指挥者类负责调用建造者类的方法来构建产品。客户端代码只需要创建指挥者对象，并将具体的建造者对象传入指挥者的构造函数中，然后通过指挥者来构建产品。

每个具体的建造者类都实现了抽象建造者类中定义的方法，用于构建不同部分的产品。而产品类负责定义产品的属性和展示方法。

使用建造者模式可以将产品的构建过程与产品本身解耦，使得构建过程可以独立于产品的组装方式。同时，通过不同的具体建造者可以构建出不同的产品变体，灵活性更高。

在示例代码中，使用了两个具体的建造者类 ConcreteBuilderA 和 ConcreteBuilderB 来构建两个不同的产品。指挥者类 Director 负责调用具体建造者的方法来构建产品。最终通过调用 getResult 方法获取构建好的产品，并展示其属性。

请注意在使用完毕后，需要手动释放内存。