工厂模式、工厂方法面试常备

1、定义汽车

#include <iostream>
using namespace std;

class Car {
    public:
    Car(string name_):name(name_){}
    ~Car(){}
    public:
    string name;
    virtual void show() {
        cout<<"this is nomore:"<<name<<endl;
    };
};

class BMW :public Car {
    public:
    BMW(string name1):Car(name1){}
    ~BMW(){}
    virtual void show() {
        cout<<"this is a BMW:"<<name<< endl;
    }
};

class BANZ:public Car {
    public:
    BANZ(string name2):Car(name2){}
    ~BANZ(){}
    virtual void show() {
        cout<<"this is a BANZ:"<<name<<endl;
    }
};

2、定义工厂

#include "car.hpp"
//工厂模式(函数版)
class Factory {
    public:
    Car* produce_bmw();
    Car* produce_banz();
    Factory(){}
    ~Factory(){}
};

Car* Factory::produce_bmw() {
    return new BMW("520i");
}
Car* Factory::produce_banz() {
    return new BANZ("E350");
}

enum cartype {
    BMW_,
    BANZ_,
    UNKNOW
};
//工厂模式（枚举版）
class Factory_1 {
    public:
    Factory_1(){}
    ~Factory_1(){}
    Car* creat_car(cartype name);
};

Car* Factory_1::creat_car(cartype name) {
    switch (name)  {
        case BMW_:
            return new BMW("730i");
        case BANZ_:
            return new BANZ("S600");
        default:
            return new Car("car");
    }
};
//工厂方法
//工厂继承的方式，避免修改代码，只增加继承类。
class Factory_base {
    public:
    Factory_base(){}
    ~Factory_base(){}
    virtual Car* creat_car(string name) {
        return new Car(name);
    }
};

class BMWFactory:public Factory_base {
    public:
    BMWFactory():Factory_base(){}
    ~BMWFactory(){}
    virtual Car* creat_car(string name);
};

class BANZFactory :public Factory_base {
    public:
    BANZFactory():Factory_base(){}
    ~BANZFactory(){}
    virtual Car* creat_car(string name);
};

Car* BMWFactory::creat_car(string name) {
    return new BMW(name);
}

Car* BANZFactory::creat_car(string name) {
    return new BANZ(name);
}

3、开始制造

#include <iostream>
#include "factory.hpp"
#include <memory>
using namespace std;


int main() {
    // //作坊生产汽车：零件都摊在上，谈好价钱现窜
    // Car* car = new Car("nihao");
    // car->show();
    // Car* banz = new BANZ("E350");
    // banz->show();
    // Car* bmw = new BMW("520i");
    // bmw->show();
    // delete banz;
    // delete bmw;
    // delete car;

    // // 工厂模式（指针版）：用工厂生产。
    // // 缺点：工厂要适配不同汽车
    // // 特点：函数确认生产的类型
    // Factory* fac = new Factory();
    // Car* banz = fac->produce_banz();
    // Car* bmw = fac->produce_bmw();
    // banz->show();
    // bmw->show();
    // delete fac;
    // delete banz;
    // delete bmw;

    // // 工厂模式（指针版）：用工厂生产。
    // // 缺点：工厂要适配不同汽车
    // // 特点：枚举确认生产类型
    // Factory_1* fac = new Factory_1();
    // Car* bmw = fac->creat_car(BMW_);
    // bmw->show();
    // Car* banz = fac->creat_car(BANZ_);
    // banz->show();
    // Car* car = fac->creat_car(UNKNOW);
    // car->show();
    // delete bmw;
    // delete banz;
    // delete car;
    // delete fac;

    // // 工厂模式（智能指针版）：用工厂生产。
    // // 缺点：工厂要适配不同汽车
    // // 特点：枚举确认生产类型
    // unique_ptr<Factory_1> fac(new Factory_1());
    // unique_ptr<Car> bmw(fac->creat_car(BMW_));
    // unique_ptr<Car> banz(fac->creat_car(BANZ_));
    // bmw->show();
    // banz->show();

    // // 工厂方法（智能指针版）：创造专有工厂。
    // // 缺点：需要建专有工厂，成本高。
    // // 特点：建专有工厂 专场专用，不需要修改代码，只需要继承子工厂就行了
    // // 创建专有工厂
    // unique_ptr<Factory_base> bmwfac(new BMWFactory());
    // unique_ptr<Factory_base> banzfac(new BANZFactory());
    // unique_ptr<Factory_base> carfac(new Factory_base());
    // //用工厂生产
    // unique_ptr<Car> bmwcar(bmwfac->creat_car ("320i"));
    // unique_ptr<Car> banzcar(banzfac->creat_car ("A200"));
    // unique_ptr<Car> car(carfac->creat_car("car"));
    // //生产出来使用  
    // bmwcar->show();
    // banzcar->show();
    // car->show(); 
}