C++ 中的创建模式

在软件开发中，创建模式是一种常用的设计模式，用于处理对象实例化的方式。

创建模式可以帮助开发人员在创建对象实例时遵守某些通用原则，以及避免过度耦合和维护困难等问题。

在 C++ 中，有多种创建模式可以使用，下面是一些常见的模式及其介绍。

工厂模式

工厂模式是最常用的创建模式之一，用于在不暴露对象创建逻辑的情况下，封装对象的实例化过程。

简单工厂模式

简单工厂模式定义了一个工厂类，该类根据传递的参数来创建并返回不同类型的对象。

class SimpleFactory {
public:
    Object* createObject(string type) {
        if (type == "ObjectA") {
            return new ObjectA();
        } else if (type == "ObjectB") {
            return new ObjectB();
        }
        return nullptr;
    }
};

在使用时，只需要创建一个工厂实例并调用其 createObject 方法即可。

SimpleFactory factory;
Object* objA = factory.createObject("ObjectA");

需要注意的是，简单工厂模式会导致工厂类中的代码过于集中，可维护性下降。

工厂方法模式

工厂方法模式使用继承来实现对象的创建过程，将创建过程分散到不同的工厂类中。

class ObjectFactory {
public:
    virtual Object* createObject() = 0;
};

class ObjectAFactory : public ObjectFactory {
public:
    Object* createObject() override {
        return new ObjectA();
    }
};

class ObjectBFactory : public ObjectFactory {
public:
    Object* createObject() override {
        return new ObjectB();
    }
};

使用时，只需要创建合适的工厂实例并调用其 createObject 方法即可。

ObjectFactory* factory = new ObjectAFactory();
Object* objA = factory->createObject();

工厂方法模式使得代码更易于扩展和维护，但可能会导致类的数量过多。

抽象工厂模式

抽象工厂模式定义了一个抽象工厂类，该类创建不同类型的相关对象组。

class AbstractFactory {
public:
    virtual ObjectA* createObjectA() = 0;
    virtual ObjectB* createObjectB() = 0;
};

class ConcreteFactory : public AbstractFactory {
public:
    ObjectA* createObjectA() override {
        return new ObjectA();
    }

    ObjectB* createObjectB() override {
        return new ObjectB();
    }
};

使用时，只需要创建合适的抽象工厂实例并调用其相关方法即可，创建出一组相关对象。

AbstractFactory* factory = new ConcreteFactory();
ObjectA* objA = factory->createObjectA();
ObjectB* objB = factory->createObjectB();

单例模式

单例模式用于保证一个类只有一个实例，并且提供全局访问点。

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

private:
    Singleton() {}
    Singleton(Singleton const&);
    void operator=(Singleton const&);
};

通过将构造函数和复制构造函数设为私有，可以保证类只有一个实例。

使用时，只需通过 getInstance 方法获取单例实例即可。

Singleton& obj = Singleton::getInstance();

单例模式使得对象的生成与管理更加简单和方便，但也需要考虑多线程安全和资源占用等问题。

原型模式

原型模式用于创建一个新对象作为现有对象的复制。

在 C++ 中，可以通过克隆对象来实现原型模式。

class Prototype {
public:
    virtual Prototype* clone() = 0;
};

class ConcretePrototype : public Prototype {
public:
    Prototype* clone() override {
        return new ConcretePrototype(*this);
    }

private:
    ConcretePrototype(ConcretePrototype const&);
    void operator=(ConcretePrototype const&);
};

使用时，可以通过原型对象的 clone 方法来复制出一个新对象。

Prototype* obj = new ConcretePrototype();
Prototype* newObj = obj->clone();

原型模式适用于对象的构造过程较为复杂且需要频繁创建相似对象的情形。

建造者模式

建造者模式用于通过一步一步的方式创建复杂的对象，并且将对象的构造细节隐藏。

class Builder {
public:
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual Product* getProduct() = 0;
};

class ConcreteBuilder : public Builder {
public:
    void buildPartA() override {
        product->setPartA("Part A");
    }

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

    Product* getProduct() override {
        return product;
    }

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

class Director {
public:
    void construct(Builder* builder) {
        builder->buildPartA();
        builder->buildPartB();
    }
};

在建造者模式中，建造者负责创建产品的各个组成部分，而指挥者负责指导建造者的构建流程。

使用时，只需要创建一个指挥者实例并调用其 construct 方法，即可建立起产品的完整实例。

Director director;
ConcreteBuilder builder;
director.construct(&builder);
Product* product = builder.getProduct();

建造者模式适用于需要创建复杂对象并且需要一步一步地完成的情况，也能够提高代码的复用和扩展性。