设计模式——创建型模式

工厂方法模式

简称工厂模式。

为一类对象的共有接口抽象出基类，工厂生产基类。

class PhoneFactory {
    static std::shared_ptr<Phone> Make();

};

class Phone {
    virtual void call() = 0;
};

class XiaoMiPhone final : public Phone {
    void call() override;
};

class iPhone final : public Phone {
    void call() override;
};

抽象工厂模式

A,B 两个工厂都生产 X,Y,Z 三种产品，有的情况下，我们只能用 A 工厂的产品。A,B 工厂的产品不会混用。

比如当我们希望代码跨平台时，我们给对一些方法进行封装，在不同平台下自动使用 windows / linux 的实现。

virtual class X;
virtual class Y;
virtual class Z;

class Factory{
    virtual X* make_X() = 0;
    virtual Y* make_Y() = 0;
    virtual Z* make_Z() = 0;
}

class AbstractFactory {
    static std::shared_ptr<Factory> Make() { return AFactory() or BFactory(); }
};

class AFactory {
    X* make_X() override;
    Y* make_Y() override;
    Z* make_Z() override;
};

class BFactory {
    X* make_X() override;
    Y* make_Y() override;
    Z* make_Z() override;
};

生成器模式

又称建造器（Builder）模式。

构造一个对象的参数过多时，考虑使用生成器模式。生成器基类中将这些属性声明为 setXXX() 方法。

class A;
class B;
class C;
class Product;
class ProductManual;

class Builder {
    virtual void setA(A a) = 0;
    virtual void setC(C c) = 0;
};

class ProductBuilder {
    void setB(B a) override;
    void setC(C a) override;
    Product get();
};

class ProductManualBuilder {
    void setA(A a) override;
    void setB(B a) override;
    void setC(C a) override;
    ProductManual get();
};

// 可选的主管
class Director {
    void build(Builder* builder) {
        if (builder is ProductManualBuilder ) {
            builder.setA();
        }
        builder.setB();
        builder.setC();
    }
};

int main()
{    
    ProductBuilder product_builder;
    ProductManualBuilder product_manual_builder;

    Director director;
    director.build(&product_builder);
    director.build(&product_manual_builder);

    Product product = product_builder.get();
    ProductManualBuilder product_manual = product_manual_builder.get();
}    

原型模式

又称克隆模式。

克隆模式允许外部调用基类的 clone() 方法，来复制派生类对象。

简单来说，基类声明 clone() 方法，子类实现之。

class Shape {
    int x;
    int y;
    std::string color;

    virtual Shape* clone() = 0;
};

class Rectangle : public Shape {
    int width;
    int height;

    Rectangle(Rectangle other) {
        this.with = other.width;
        this.height = other.height;
    }

    Shape* clone() override {
        return new Rectangle(this);
    }

};

class Circle : public Shape {
    int radius;

    Circle(Circle other) {
        this.radius = other.radius;
    }

    Shape* clone() override {
        return new Circle(this);
    }
};

单例模式

无需多言。