factory mothed pattern--工厂方法模式

factory mothed pattern，称工厂方法模式

首先我们看看Gof怎么定义工厂方法模式的:

“Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.”  - GoF

"为创建一个对象而定义一个接口，让子类决定哪个类实例化，工厂方法模式使类的实例化延迟到子类"-GoF

抽象工厂(AbstractFactory)：     是工厂方法模式的核心。具体工厂必须实现在抽象工厂中定义的抽象方法。

具体工厂(ConcreteFactory)：   实现抽象工厂中定义的所有抽象方法，包含与业务密切相关的逻辑。

抽象产品(AbstractProduct)：     所有具体产品的超类，亦即具体产品的共同父类。

具体产品(ConcreteProduct)：   这个角色实现了抽象产品角色所定义的接口。

在C++中，其实就是运用的C++多态性质。

实例：

一个工厂生产奔驰轿车，一个工厂生成奥迪轿车，同时要进行测试。

class Car
{
    public:
        virtual void run( )=0;
};

class AudiCar:public Car
{
    public:
        void run( );
};
void AudiCar::run( )
{
        std::cout<<"Audi is running"<<std::endl;
} 

class BenzCar:public Car
{
    public:
        void run( );
}
void BenzCar::run( )
{
        std::cout<<"Benz is running"<<std::endl;
};

class CarFactory
{
    public:
       virtual Car * createCar( )=0;
};

class AudiCarFactory:public CarFactory
{
    public:
        Car * createCar( );
};
Car * AudiCarFactory::createCar( )
{
        return new AudiCar( );
}

class BenzCarFactory:public CarFactory
{
    public:
        Car * createCar( );
};
Car* BenzCarFactory::createCar( )
{
        return new BenzCar( );
}

void createAndTest(CarFactory* p)
{
    car* c=p->createCar( );
    c->run( );
    delete c;
}

int main (int argc,char* argv)
{
    CarFactory * p1 =new BenzCarFactory( );        //由子类决定实例化对象
    CarFactory * p2 =new AudiCarFactory( );
    createAndTest(p1);
    createAndTest(p2);
    delete p1;
    delete p2;
    return 0;
}

 

运行结果：