设计模式-工厂模式

工厂模式用来创建对象，不会对外暴露创建逻辑，工厂模式分为简单工厂模式，工厂方法模式，抽象工厂模式

简单工场模式

简单工厂模式只有一个工厂，使用方法比较简单。比较适合一种产品的对象创建以及扩展。如果需要新的衍生产品只需要继承car，然后在工厂中new出来就可以了。在具体对象创建过程中可以做具体的操作，提前设置一些前提条件，以便后续访问。

enum CarType{BENZ, 
             BMW};

class Car
{
public:
    virtual void ShowCarType(void) = 0;
	virtual ~Car(){};  //一定要是虚函数，否则在衍生类析构时会造成内存泄漏
};

class BenzCar : public Car //奔驰车
{
public:
    BenzCar()
    {
        cout<<"Benz::Benz()"<<endl;
    }
    virtual void ShowCarType(void)
    {
        cout<<"BenzCar::ShowCarType()"<<endl;
    }
    ~BenzCar()
    {

    }
};

class BmwCar : public Car //宝马车
{
public:
    BmwCar()
    {
        cout<<"Bmw::Bmw()"<<endl;
    }
    virtual void ShowCarType(void)
    {
        cout<<"BmwCar::ShowCarType()"<<endl;
    }
};


class CarFactory //车厂
{
public:
    Car* createSpecificCar(CarType type)
    {
        switch(type)
        {
        case BENZ://生产奔驰车
            return (new BenzCar());
            break;
        case BMW://生辰宝马车
            return (new BmwCar());
            break;
        default:
            return NULL;
            break;
        }
    }
};
int main(int argc, char** argv)
{
    CarFactory carfac;
    Car* BenA = carfac.createSpecificCar(BENZ);
    Car* BmwB = carfac.createSpecificCar(BMW);

    delete BenA; 
	delete BenA;
    
    return 0;
}

工厂方法模式

该模式下一种产品会有一种工厂去生产。该模式的优点是有体现了类的单一原则，使对象的生成有更大的操作空间，增加了代码的可读性，便于维护。缺点是增加了代码量，一个产品就需要一个工厂类。

class Car //车 
{
public:
    virtual void ShowCarType(void) = 0;
	virtual ~Car(){};   
};

class BenzCar : public Car //奔驰车
{
public:
    BenzCar()
    {
        cout<<"Benz::Benz()"<<endl;
    }
    virtual void ShowCarType(void)
    {
        cout<<"BenzCar::ShowCarType()"<<endl;
    }
    ~BenzCar()
    {

    }
};

class BmwCar : public Car //宝马车
{
public:
    BmwCar()
    {
        cout<<"Bmw::Bmw()"<<endl;
    }
    virtual void ShowCarType(void)
    {
        cout<<"BmwCar::ShowCarType()"<<endl;
    }
};

class Factory
{
public:
    virtual car* CreateCar() = 0;
};

class BenzCarFactory ： public Factory
{
	virtual car* CreateCar()
	{
	    return new BenzCar();
	}
}

class BmwCarFactory :public Factory
{
    virtual car* CreateCar()
    {
	    return new BmwCar();
    }
}
int main()
{
    Factory* Bmw = new BmwCarFactory();
	car* BmwCar = Bmw->CreateCar();
	Factory* BENZ = new BenzCarFactory();
	car* BENZCar = BENZ->CreateCar();
	delete Bmw;
	delete BmwCar;
	delete BENZ;
	delete BENZCar;
}

抽象工厂模式

抽象工厂模式是在工厂模式上稍加改进来的。在同种类产品类型中，用专门生产该种类的产品的工厂进行生产。该模式下同种类产品扩展比较方便，如果是新增一个产品类型就比较麻烦了，需要新增产品类和工厂

class Car //车 
{
public:
    virtual void ShowCarType(void) = 0;
	virtual ~Car(){};   
};

class BenzCar : public Car //奔驰车
{
public:
    BenzCar()
    {
        cout<<"Benz::Benz()"<<endl;
    }
    virtual void ShowCarType(void)
    {
        cout<<"BenzCar::ShowCarType()"<<endl;
    }
    ~BenzCar()
    {

    }
};

class BmwCar : public Car //宝马车
{
public:
    BmwCar()
    {
        cout<<"Bmw::Bmw()"<<endl;
    }
    virtual void ShowCarType(void)
    {
        cout<<"BmwCar::ShowCarType()"<<endl;
    }
};

class BmwX5Car : public BmwCar
{
public:
    BmwX5Car()
    {
	    cout<<"BmwX5Car:BmwX5Car()"<<endl;
	}
    virtual void ShowCarType(void)
    {
        cout<<"BmwX5Car::ShowCarType()"<<endl;
    }	
}

class Factory
{
public:
    virtual car* CreateCar() = 0;
	virtual car* CreateX5Car() = 0;
};

class BenzCarFactory ： public Factory
{
	virtual car* CreateCar()
	{
	    return new BenzCar();
	}
}

class BmwCarFactory :public Factory
{
    virtual car* CreateCar()
    {
	    return new BmwCar();
    }
	virtual car* CreateX5Car()
	{
	    return new BmwX5Car();
	}
}

测试代码

int main()
{
    Factory* Bmw = new BmwCarFactory();
	car* BmwCar = Bmw->CreateCar();
	Factory* BENZ = new BenzCarFactory();
	car* BENZCar = BENZ->CreateCar();
	car* BmwX5 = Bmw->CreateX5Car();
	delete Bmw;
	delete BmwCar;
	delete BENZ;
	delete BENZCar;
}