面试十 简单工厂、工厂方法、抽象工厂

/*

 简单工厂 Simple Factory：
    优点：
        把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象，客户不用自己负责new对象
    缺点 ：
        提供创建对象实例的接口函数不闭合，不能对修改关闭，对扩展开放

 工厂方法 Factory Method

    优点：
        Factory基类，提供一个纯虚函数（创建产品），定义派生类（具体产品的工厂）负责创建对应的产品，可以做到不同的产品在不同的工厂创建，能够对现有工厂，以及产品的修改关闭
    缺点：
        实际上，很多产品是有关联关系的，属于一个产品族，不应该放在不同的工厂取创建，这样一不符合实际的产品对象创建逻辑，二是工厂类太多了，不好维护

 抽象工厂 Abstract Factory
    把有关联关系的，属于一个产品族的所有产品创建的接口函数，放在一个抽象工厂里面AbstractFactory，派生类（具体产品的工厂）应该负责创建该产品簇里面的所有产品


 工厂模式： 主要是封装了对象的创建

*/

简单工厂模式（Simple Factory Pattern）：

• 简单工厂模式是一种由一个工厂类根据传入的参数决定创建哪一种产品类的实例的设计模式。
• 客户端通过向工厂类传递指定的参数来获取所需的产品对象，而无需直接实例化具体的产品类。
• 简单工厂模式的核心是一个工厂类，它包含了必要的逻辑判断，根据不同的条件创建不同的产品对象。

class Car
{
public:
    Car(string name) :_name(name) {}
    virtual void show() = 0;
protected:
    string _name;
};
class Bmw:public Car
{
public:
    Bmw(string name) :Car(name) {}
    void show()
    {
        cout << "获取了一辆宝马汽车：" << _name << endl;
    }
};

class Audi :public Car
{
public:
    Audi(string name) :Car(name) {}
    void show()
    {
        cout << "获取了一辆奥迪汽车：" << _name << endl;
    }
};

// 产品枚举
enum Cartype
{
    BMW, AUDI
};
// 简单工厂类
class SimpleFactory
{
public:
    // 用户想要创建一个对象，只需要知道名称就可以了
    Car* createCar(Cartype ct)
    {
        switch (ct)
        {
            case BMW:
                return new Bmw("x6");
            case AUDI:
                return new Audi("a8");
            default:
                cerr << "传入参数错误：" << ct << endl;
        }
        return nullptr;
    }
};

int main()
{
    unique_ptr<SimpleFactory> fac(new SimpleFactory());
    unique_ptr<Car> p1(fac->createCar(BMW));
    unique_ptr<Car> p2(fac->createCar(AUDI));

    p1->show();
    p2->show();

    return 0;
}

工厂方法模式（Factory Method Pattern）：

• 工厂方法模式定义了一个用于创建对象的接口，但将具体创建工作推迟到子类中。
• 工厂方法模式通过在父类中定义一个创建对象的抽象方法，让子类来实现这个方法来创建具体的产品对象。
• 每个具体的工厂类都负责创建一类产品。

// 系列产品
class Car
{
public:
    Car(string name) :_name(name) {}
    virtual void show() = 0;
protected:
    string _name;
};
class Bmw:public Car
{
public:
    Bmw(string name) :Car(name) {}
    void show()
    {
        cout << "获取了一辆宝马汽车：" << _name << endl;
    }
};
class Audi :public Car
{
public:
    Audi(string name) :Car(name) {}
    void show()
    {
        cout << "获取了一辆奥迪汽车：" << _name << endl;
    }
};

// 基类（包含纯虚函数，不能实例化对象）
class Factory
{
public:
    virtual Car* createCar(string name) = 0;
};
// 宝马汽车工厂，负责生产宝马汽车
class BmwFac: public Factory
{
public:
    Car* createCar(string name)
    {
        return new Bmw(name);
    }
};

// 奥迪汽车工厂，负责生产奥迪汽车
class AudiFac :public Factory
{
public:
    Car* createCar(string name)
    {
        return new Audi(name);
    }
};


int main()
{
    unique_ptr<Factory> bmwfty(new BmwFac());
    unique_ptr<Factory> audifty(new AudiFac());
    unique_ptr<Car> p1 (bmwfty->createCar("X6"));
    unique_ptr<Car> p2 (audifty->createCar("A8"));

    p1->show();
    p2->show();

    return 0;
}

抽象工厂模式（Abstract Factory Pattern）：

• 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
• 抽象工厂模式包含一个抽象工厂类，它声明了一组用于创建一系列产品的抽象方法。每个具体的工厂类负责创建一族产品，通常对应于一个产品等级结构。
• 抽象工厂模式关注的是一系列相关的产品对象的创建，而不是单个产品对象的创建。

// 系列产品1：汽车
class Car
{
public:
    Car(string name) :_name(name) {}
    virtual void show() = 0;
protected:
    string _name;
};
class Bmw:public Car
{
public:
    Bmw(string name) :Car(name) {}
    void show()
    {
        cout << "获取了一辆宝马汽车：" << _name << endl;
    }
};
class Audi :public Car
{
public:
    Audi(string name) :Car(name) {}
    void show()
    {
        cout << "获取了一辆奥迪汽车：" << _name << endl;
    }
};
// 系列产品2：车灯
class Light
{
public:
    virtual void show() = 0;
};
class BmwLight : public Light
{
public:
    void show() { cout << "BMW light!" << endl; }
};
class AudiLight : public Light
{
public:
    void show() { cout << "Audi light!" << endl; }
};



// 工厂方法 => 抽象工厂(对有一组关联关系的产品簇提供产品对象的统一创建)
class AbstractFactory
{
public:
    virtual Car* createCar(string name) = 0; // 工厂方法 创建汽车
    virtual Light* createCarLight() = 0; // 工厂方法 创建汽车关联的产品，车灯
};
// 宝马工厂
class BMWFactory : public AbstractFactory
{
public:
    Car* createCar(string name)
    {
        return new Bmw(name);
    }
    Light* createCarLight()
    {
        return new BmwLight();
    }
};
// 奥迪工厂
class AudiFactory : public AbstractFactory
{
public:
    Car* createCar(string name)
    {
        return new Audi(name);
    }
    Light* createCarLight()
    {
        return new AudiLight();
    }
};


int main()
{
    unique_ptr<AbstractFactory> bmwfty(new BMWFactory());
    unique_ptr<AbstractFactory> audifty(new AudiFactory());
    unique_ptr<Car> p1(bmwfty->createCar("X6"));
    unique_ptr<Car> p2(audifty->createCar("A8"));
    unique_ptr<Light> l1(bmwfty->createCarLight());
    unique_ptr<Light> l2(audifty->createCarLight());

    p1->show();
    l1->show();

    p2->show();
    l2->show();

    return 0;
}