设计模式-工厂模式

工厂模式

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

简单工厂 Simple Factory

把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象，呵护不用自己负责new对象，不用了解对象创建的详细过程

提供创建对象实例的接口函数不闭合，不能对修改关闭

工厂方法 FactoryMethod

Factory基类，提供了一个纯虚函数（创建商品），定义派生类（具体产品的工厂）负责创建产品，可以做到不同的产品，在不同的工厂里面创建，能够对现有工厂，以及产品的修改关闭

实际上，很多产品是右关联关系的，属于一个产品簇，不应该放在不同的工厂里去创建，一不符合实际产品对象创建逻辑，而是工厂类太多了，不好维护

抽象工厂 AbstractFactory

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

简单工厂 SimpleFactory

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* creatCar(CarType ct) {
        switch (ct)
        {
        case BMW:
            return new Bmw("X1");
        case AUDI:
            return new Audi("A6");
        default:
            cerr << "传入工厂的参数不正确：" << ct << endl;
            break;
        }
        return nullptr;
    }
};
int main() {
    //Car* p1 = new BMW("x1");
    //
    // Car* p2 = new Audi("A6");
    //智能指针
    unique_ptr<SimpleFactory> factory(new SimpleFactory());
    unique_ptr<Car> p1(factory->creatCar(BMW));
    unique_ptr<Car> p2(factory->creatCar(AUDI));
    p1->show();
    p2->show();
    
    return 0;
}

但是简单工厂不满足开闭原则

工厂方法 FactoryMethod

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* creatCar(string name) = 0;//工厂方法
};
//宝马工厂
class BmwFactory :public Factory {
public:
    Car* creatCar(string name) {
        return new Bmw(name);
    }
};
//奥迪工厂
class AudiFactory :public Factory {
public:
    Car* creatCar(string name) {
        return new Audi(name);
    }
};
​
int main() {
    unique_ptr<Factory> bmwFactory(new BmwFactory());
    unique_ptr<Factory> audifactory(new AudiFactory());
    unique_ptr<Car> p1(bmwFactory->creatCar("x6"));
    unique_ptr<Car> p2(audifactory->creatCar("a8"));
    p1->show();
    p2->show();
    return 0;
}
​

抽象工厂 AbstractFactory

//产品系列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* creatCar(string name) = 0;//工厂方法
    virtual Light* creatLight() = 0;
};
//宝马工厂
class BmwFactory :public AbstractFactory {
public:
    Car* creatCar(string name) {
        return new Bmw(name);
    }
    Light* creatLight() {
        return new BmwLight();
    }
};
//奥迪工厂
class AudiFactory :public AbstractFactory {
public:
    Car* creatCar(string name) {
        return new Audi(name);
    }
    Light* creatLight() {
        return new AudiLight();
    }
};
​
int main() {
    unique_ptr<AbstractFactory> bmwFactory(new BmwFactory());
    unique_ptr<AbstractFactory> audifactory(new AudiFactory());
    unique_ptr<Car> p1(bmwFactory->creatCar("x6"));
    unique_ptr<Car> p2(audifactory->creatCar("a8"));
    unique_ptr<Light> l1(bmwFactory->creatLight());
    unique_ptr<Light> l2(audifactory->creatLight());
    p1->show();
    l1->show();
    p2->show();
    l2->show();
    return 0;
}