工厂模式：工厂方法模式 和 抽象工厂模式

工厂方法模式：优化，工厂类也分子类和父类

流程：

实例：

#include <iostream>
using namespace std;
/*抽象产品类 TV(电视机类)*/ 
class TV
{
public:
virtual void Show() = 0;
virtual ~TV();//声明析构函数为虚函数，防止内存泄漏
};

/*具体产品类 HairTV(海尔电视机类)*/ 
class HairTV : public TV
{
public:
void Show()
{
cout<< "I'm HairTV"<<endl;
}
};

/*具体产品类 HisenseTV(海信电视机类)*/
class HisenseTV : public TV
{
public:
void Show()
{
cout<< "I'm HisenseTV"<<endl;
}
};

/*工厂类(电视机工厂类)*/  
class TVFactory
{
public:
virtual TV *CreateTV() = 0;
virtual ~TVFactory(){};//析构函数声明为虚函数，防止内存泄漏
};

/*具体工厂类 HairTVFactory(海尔电视机工厂类)*/ 
class HairTVFactory : public TVFactory
{
public:
TV *CreateTV()
{
return new HairTV ();
}
};

/*具体工厂类 HisenseTV(海信电视机工厂类)*/ 
class HisenseTVFactory : public TVFactory
{
public:
TV *CreateTV()
{
return new HisenseTV ();
}
};

int main(int argc , char *argv [])
{
TVFactory *hairTVFactory = new HairTVFactory();
TV *hairTV = hairTVFactory->CreateTV();
hairTV->Show();

TVFactory *hisenseTVFactory = new HisenseTVFactory();
TV *hisenseTV = hisenseTVFactory->CreateTV();
hisenseTV->Show();

if (hairTVFactory!= NULL)
{
delete hairTVFactory;
hairTVFactory = NULL;
}

if (hairTV != NULL)
{
delete hairTV;
hairTV = NULL;
}

if (hisenseTVFactory != NULL)
{
delete hisenseTVFactory;
hisenseTVFactory = NULL;
}

if (hisenseTV != NULL)
{
delete hisenseTV;
hisenseTV = NULL;
}
return 0;
}

工厂类也分为子类和父类，子类工厂专门负责生产子类产品，它们是一一对应的关系。所以，当新添加子类产品时，只需要新添加一个工厂子类即可，不需要再原来的代码上修改，从而提高了扩展性。

抽象工厂模式：一个工厂子类生产多个产品子类

流程：

实例：

HairTV 和 HairAC 都由 Hair工厂子类来生产，但注意，这两个子类产品都是Hair品牌，也就是说，它们之间是有联系的

#include <iostream>
using namespace std;
  
// 抽象产品类类 Television(电视机类)
class Television
{
public:
    virtual void Show() = 0;
    virtual ~Television(){};//析构函数声明为虚函数，防止内存泄漏
};
 
//具体产品类 HaierTelevision（海尔电视机类）
class HaierTelevision : public Television
{
public:
    void Show()
    {
        cout << "I'm HaierTelevision" << endl;
    }
};
//具体产品类 TCLTelevision（TCL电视机类）
class TCLTelevision : public Television
{
public:
    void Show()
    {
        cout << "I'm TCLTelevision" << endl;
    }
};
 
// 抽象产品类  AirCondition（空调类）
class AirCondition
{
public:
    virtual void Show() = 0;
    virtual ~AirCondition(){};//析构函数声明为虚函数，防止内存泄漏
};

//具体产品类 HairAirCondition(海尔空调类)
class HairAirCondition : public AirCondition
{
public:
    void Show()
    {
        cout << "I'm HairAirCondition" << endl;
    }
};

//具体产品类 TCLAirCondition(TCL空调类)
class TCLAirCondition : public AirCondition
{
public:
    void Show()
    {
        cout << "I'm TCLAirCondition" << endl;
    }
};
 
// 抽象工厂类 EFactory(电器工厂类)
class EFactory
{
public:
    virtual Television* CreateTelevision() = 0;
    virtual AirCondition* CreateAirCondition() = 0;
     virtual ~EFactory(){};//析构函数声明为虚函数，防止内存泄漏
};

//具体工厂类 HairFactory(海尔工厂类)
class HairFactory : public EFactory
{
public:
    Television* CreateTelevision()
    {
        return new HaierTelevision();
    }
 
    AirCondition* CreateAirCondition()
    {
        return new HairAirCondition();
    }
};

//具体工厂类 TCLFactory(TCL工厂类) 
class TCLFactory : public EFactory
{
public:
    Television* CreateTelevision()
    {
        return new TCLTelevision();
    }
 
    AirCondition* CreateAirCondition()
    {
        return new TCLAirCondition();
    }
};
  
int main(int argc, char *argv[])
{
  EFactory *hairFactory = new HairFactory ();/*实例化工厂抽象类*/
  Television *haierTelevision =hairFactory->CreateTelevision();/*实例化产品抽象类*/
  AirCondition *haierAirCondition = hairFactory->CreateAirCondition();
  
  haierTelevision->Show();
  haierAirCondition->Show();
  
  EFactory *tCLFactory = new TCLFactory ();
  Television *tCLTelevision = tCLFactory->CreateTelevision();
  AirCondition *tCLAirCondition = tCLFactory->CreateAirCondition();
  
  tCLTelevision->Show();
  tCLAirCondition->Show();
  
  if (hairFactory != NULL)
  {
    delete hairFactory;
    hairFactory = NULL;
  }
  
  if (haierTelevision != NULL)
  {
    delete haierTelevision;
    haierTelevision= NULL;
  }
  
  if (tCLAirCondition != NULL)
  {
    delete tCLAirCondition;
    tCLAirCondition = NULL;
  }
  
  if (tCLFactory != NULL)
  {
    delete tCLFactory;
    tCLFactory= NULL;
  }
  
  if (tCLTelevision != NULL)
  {
    delete tCLTelevision;
    tCLTelevision = NULL;
  }
  
  if (tCLAirCondition != NULL)
  {
    delete tCLAirCondition;
    tCLAirCondition = NULL;
  }
}

一个工厂子类可以生产一个产品族，抽象工厂模式适合不同类的产品之间有联系的情况