C++ 工厂模式

1.简单工厂模式
特点:需要在工厂类中做判断，从而创造相应的产品

enum eTYPE{ MASTER, SOLIDER}; // 法师、战士

// 虚基类
class Role
{
public:
    virtual void show() = 0;
    virtual void Init() = 0;
};

class Master : public CRole
{
public:
    
    void show()
    {
        std::cout<<"This is a master"<<std::endl;
    }
    
    void Init()
    {
        ...
    }
};

class Solider : public CRole
{
public:
    void show()
    {
        std::cout<<"This is a solider"<<std::endl;
    }
    
    void Init()
    {
        ...
    }
};

class Factory
{
public:
    CRole* create(eTYPE type)
    {
        CRole * pRole = NULL;
        switch(type):
        {
            case MASTER:
                pRole = new Master;
                break;
            case SOLIDER:
                pRole = new Solider;
                break;        
        }
    }
    
    if(pRole)
    {
        pRole->Init();
    }
    
    return pRole;
};

缺点:
每次新增类都需要改动Factory工厂类的分支。

 

   简单工厂模式的UML图：

 

2.工厂模式
特点:定义一个用于创建对象的接口，然后让子类去决定实例化哪个类。使一个类的实例化延迟到其子类中。

class Factory
{
public:
    virtual CRole * create() = 0; 
};

class MasterFactory : public Factory
{
public:
    Master * create()
    {
        return new Master;
    }
};

class SoliderFactory : public Factory
{
public:
    Solider * create()
    {
        return new Solider;
    }
};

缺点:
每增加一个产品，就需要创建一个新的工厂。
相对 简单工厂模式， 工厂模式 需要定义 更多的 工厂类， 简单工厂模式只需要一个工厂，然后在工厂里根据switch划分.

 

 工厂方法的UML图：

 

 

3.抽象工厂模式
特点:提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的具体类。
提供某一类产品的工厂。

class Single
{
public:
    virtual void show() = 0;
}; 

class SingleA : public Single
{
public:
    void show()
    {
        std::cout<<"SingleA"<<std::endl;
    }
};

class SingleB : public Single
{
    void show()
    {
        std::cout<<"SingleB"<<std::endl;
    }
};
 
////

class Multiple
{
public:
    virtual void show() = 0;
};

class MultipleA : public Multiple
{
public:
    void show()
    {
        std::cout<<"MultipleA"<<std::endl;
    }
};

class MultipleB : public Multiple
{
    void show()
    {
        std::cout<<"MultipleB"<<std::endl;
    }
};

class Factory
{
public:
    virtual Single * createSingle() = 0;
    virtual Multiple * createMultiple() = 0;
};

// FactoryA 专门来生产 A型号 的东西
class FactoryA : public Factory
{
public:
    Single * createSingle()
    {
        return new SingleA();
    }
    
    Multiple * createMultiple()
    {
        return new MultipleA();
    }
};

// FactoryB 专门生产 B型号 的东西
class FactoryB : public Factory
{
public:
    Single * createSingle()
    {
        return new SingleB();
    }
    
    Multiple * createMultiple()
    {
        return new MultipleB();
    }
};

 

   抽象工厂模式的UML图：