《面试准备》C++工厂模式

工厂模式

参考：https://www.cnblogs.com/huiz/p/8232783.html

１、简单工厂模式

在工厂类做判断，从而创建相应的产品，当增加产品时需要修改工厂类。

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

//简单工厂模式
//枚举
enum cartype{benci,baoma};
//抽象类(多态:提高基类)
class car{
public:
    virtual void createcar(void)=0;
};
//具体类(产品1)
class bencicar:public car{
public:
    bencicar(){
        cout<<" begin create bencicar "<<endl;
    }
    void createcar(void){
        cout<<" creating bencicar "<<endl;
    }
    ~bencicar(){}
};
//具体类(产品2)
class baomacar:public car{
public:
    baomacar(){
        cout<<" begin create baomacar "<<endl;
    }
    void createcar(void){
        cout<<" creating baomacar "<<endl;
    }
    ~baomacar(){}
};
//工厂类
class carfactory{
public:
    car* createSpecificCar(cartype type){
        switch(type){
        case benci:
            return (new bencicar());
            break;
        case baoma:
            return (new baomacar());
            break;
         default:
            return NULL;
            break;
        }
    }
};

int main(){
    carfactory producecar;
    car *newcar1 = producecar.createSpecificCar(benci);
    car *newcar2 = producecar.createSpecificCar(baoma);
    newcar1->createcar();
    newcar2->createcar();
    return 0;
}

２、工厂方法模式

抽象工厂类，只提供一个接口，通过子类去扩展和实现

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

//工厂方法模式

//抽象类(多态:提高基类)
class car{
public:
    virtual void createcar(void)=0;
};
//具体类(产品1)
class bencicar:public car{
public:
    bencicar(){
        cout<<" begin create bencicar "<<endl;
    }
    void createcar(void){
        cout<<" creating bencicar "<<endl;
    }
    ~bencicar(){}
};
//具体类(产品2)
class baomacar:public car{
public:
    baomacar(){
        cout<<" begin create baomacar "<<endl;
    }
    void createcar(void){
        cout<<" creating baomacar "<<endl;
    }
    ~baomacar(){}
};
//抽象工厂类，提供创建产品类的接口
class carfactory{
public:
    virtual car* createSpecificCar()=0;
};

//工厂类子类
class bencifactory:public carfactory{
    car* createSpecificCar(){
        return (new bencicar());
    }
};
//工厂类子类
class baomafactory:public carfactory{
    car* createSpecificCar(){
        return (new baomacar());
    }
};

int main(){
    carfactory *producecar1 = new bencifactory();
    car *newcar1 = producecar1->createSpecificCar();
    newcar1->createcar();
    carfactory *producecar2 = new baomafactory();
    car *newcar2 = producecar2->createSpecificCar();
    newcar2->createcar();
    return 0;
}

 ３、抽象工厂模式

当存在多个产品系列，而客户端只使用一个系列的产品时（选择普通产品还是高配产品），可以考虑使用抽象工厂模式。

缺点：当增加一个新系列的产品时，不仅需要现实具体的产品类，还需要增加一个新的创建接口，扩展相对困难。

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

//工厂方法模式

//抽象类(多态:提高基类)
class car{
public:
    virtual void createcar(void)=0;
};
class highcar{
public:
    virtual void createcar(void)=0;
};
//具体类(产品1)
class bencicar:public car{
public:
    bencicar(){
        cout<<" begin create bencicar "<<endl;
    }
    void createcar(void){
        cout<<" creating bencicar "<<endl;
    }
    ~bencicar(){}
};
//具体类(产品1,高性能)
class highbencicar:public highcar{
public:
    highbencicar(){
        cout<<" begin create highbencicar "<<endl;
    }
    void createcar(void){
        cout<<" creating highbencicar "<<endl;
    }
    ~highbencicar(){}
};
//具体类(产品2)
class baomacar:public car{
public:
    baomacar(){
        cout<<" begin create baomacar "<<endl;
    }
    void createcar(void){
        cout<<" creating baomacar "<<endl;
    }
    ~baomacar(){}
};
//具体类(产品2,高性能)
class highbaomacar:public highcar{
public:
    highbaomacar(){
        cout<<" begin create highbaomacar "<<endl;
    }
    void createcar(void){
        cout<<" creating highbaomacar "<<endl;
    }
    ~highbaomacar(){}
};
//抽象工厂类，提供创建产品类的接口
class carfactory{
public:
    virtual car* createSpecificCar()=0;
    virtual highcar* createSpecificHightCar()=0;
};

//工厂类子类
class bencifactory:public carfactory{
    car* createSpecificCar(){
        return (new bencicar());
    }
    highcar* createSpecificHightCar(){
        return (new highbencicar());
    }
};
//工厂类子类
class baomafactory:public carfactory{
    car* createSpecificCar(){
        return (new bencicar());
    }
    highcar* createSpecificHightCar(){
        return (new highbaomacar());
    }
};

int main(){
    carfactory *producecar1 = new bencifactory();
    car *newcar1 = producecar1->createSpecificCar();
    newcar1->createcar();
    carfactory *producecar2 = new baomafactory();
    highcar *newcar2 = producecar2->createSpecificHightCar();
    newcar2->createcar();
    return 0;
}