design pattern——factory

model

implement

product

class Product
{
protected:
    Product();
    
public:
    virtual ~Product() = 0;
};

Product::Product()
{
}

Product::~Product()
{
}

concrete product

class ConcreteProduct1 : public Product
{
public:
    ConcreteProduct1();
    ~ConcreteProduct1();
};

class ConcreteProduct2 : public Product
{
public:
    ConcreteProduct2();
    ~ConcreteProduct2();
};

ConcreteProduct1::ConcreteProduct1()
{
    cout << "ConcreteProduct1..." << endl;
}

ConcreteProduct1::~ConcreteProduct1()
{
}

ConcreteProduct2::ConcreteProduct2()
{
    cout << "ConcreteProduct2..." << endl;
}

ConcreteProduct2::~ConcreteProduct2()
{
}

factory

class Factory
{
protected:
    Factory();
    
public:
    virtual ~Factory() = 0;
    
public:
    virtual Product* CreateProduct(int productType) = 0;
};

Factory::Factory()
{
}

Factory::~Factory()
{
}

concrete factory

class ConcreteFactory : public Factory
{
public:
    ConcreteFactory();
    ~ConcreteFactory();
    
public:
    Product* CreateProduct(int productType);
};

ConcreteFactory::ConcreteFactory()
{
    cout << "ConcreteFactory..." << endl;
}

ConcreteFactory::~ConcreteFactory()
{
}

Product* ConcreteFactory::CreateProduct(int productType)
{
    if(productType == 1)
    {
        return new ConcreteProduct1();
    }
    if(productType == 2)
    {
        return new ConcreteProduct2();
    }
    
    return NULL;
}

应用

void factory_test()
{
    Factory* factory = new ConcreteFactory();
    Product* product1 = factory->CreateProduct(1);
    Product* product2 = factory->CreateProduct(2);
}

总结

• 抽象：concrete product的公共基类Product进行了抽象，concrete factory的基类Factory进行了抽象
• 扩展：concrete product可以进行扩展
• 开发者不需要知道concrete product和concrete factory，开发者只与公共基类Product和基类Factory交互