C++工厂模式
一、工厂模式是什么？
是C++多态的一种很好的具体表现。通过继承，重写抽象父类的虚函数，并在main函数中通过基类指针指向子类对象的一种编码风格
二、为什么使用工厂模式
1.如果每次需要的对象构造过程都比较复杂，那么就需要很多行的代码去能去创建一个对象。这样就比较麻烦！
2.如果在别的类中又需要创建该对象，那么代码的重复度就很高。
3.需要通过一个工具类，把每个对象创建的具体逻辑给隐藏起来，且只对外分别暴露一个个调用方法。这样就减少了代码量，以后如果想改代码的话，只需要改一处即可，也方便我们日常的维护。
4.该工具类就是工厂模式思想落地实现的一种具体情况，现在只不过很多框架都会自带工厂模式的实现接口。一般不需要我们自己手写，只需简单配置一下就可以使用了
二、怎样实现
1.简单工厂模式
只有一个抽象类，所以它存在的缺点是工厂类中集中了所有的创建逻辑，高内聚的问题并没有得到解决。当需要增加产品时，工厂类需要进行修改，违背了六大准则第一条开闭原则，没有良好的扩展性。但它存在并非偶然，优点是对外隐藏了内部的创建，有利于整个结构的优化。
需要的类
（1）抽象产品类（作为个具体产品基类 、 包含共有的可显示自身产品信息的纯虚方法、 析构函数需要定义为虚函数（多态方面原因））
（2）具体产品类
（3）抽象工厂类（有创建具体产品的方法）
代码如下（示例）：使用静态局部变量
#include <iostream>
typedef enum
{
Shoes,
Coat,
Pants
}CLOTHTYPE;
class clothing
{
public:
virtual void show() = 0;
virtual ~clothing() {}
};
class shoes:public clothing
{
public:
void show()
{
std::cout << "I'm shoes!" << std::endl;
};
};
class coat :public clothing
{
public:
void show()
{
std::cout << "I'm coat!" << std::endl;
}
};
class pants:public clothing
{
public:
void show()
{
std::cout << "I'm pants!" << std::endl;
}
};
class factory
{
public:
clothing* producecloth(CLOTHTYPE clothtype)
{
switch (clothtype)
{
case Shoes:return new shoes();
case Coat:return new coat();
case Pants:return new pants();
default:
return NULL;
}
}
};
int main()
{
factory m_factory;
clothing* coat1 = m_factory.producecloth(CLOTHTYPE::Coat);
if(coat1)
coat1->show();
clothing* shoes1 = m_factory.producecloth(CLOTHTYPE::Shoes);
if (shoes1)
shoes1->show();
clothing* pants1 = m_factory.producecloth(CLOTHTYPE::Pants);
if (pants1)
pants1->show();
std::cout << "Hello World!\n";
}
输出结果
I'm coat!
I'm shoes!
I'm pants!
Hello World!
注：
2.工厂方法模式
一个具体的工厂生产一个具体的产品
需要的类
（1）抽象产品类（作为个具体产品基类 、 包含共有的可显示自身产品信息的纯虚方法、 析构函数需要定义为虚函数（多态方面原因））
（2）具体产品类（继承抽象产品类）
（3）抽象工厂类（工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现）
（4）具体工厂类（继承于抽象工厂，实现创建对应具体产品对象的方式）
代码如下（示例）
#include <iostream>
class Clothing
{
public:
virtual void show() = 0;
virtual ~Clothing() {}
};
class Cloes :public Clothing
{
void show()
{
std::cout << "I'm cloes!" << std::endl;
}
};
class Coat :public Clothing
{
void show()
{
std::cout << "I'm coat!" << std::endl;
}
};
class Factory
{
public:
virtual Clothing* creatfactory() = 0;
virtual ~Factory() {}
};
class ShoesFactory:public Factory
{
public:
Clothing* creatfactory()
{
return new Cloes;
}
};
class CoatFactory :public Factory
{
public:
Clothing* creatfactory()
{
return new Coat;
}
};
int main()
{
Factory* shoes_factory = new ShoesFactory();
Clothing * m_shoes = shoes_factory->creatfactory();
if (m_shoes)
{
m_shoes->show();
delete m_shoes;
m_shoes = NULL;
}
Factory* coat_factory = new CoatFactory();
Clothing* m_coat = coat_factory->creatfactory();
if (m_coat)
{
m_coat->show();
delete m_coat;
m_coat = NULL;
}
//std::cout << "Hello World!\n";
}
输出结果
I'm cloes!
I'm coat!
3、抽象工厂模式
一个具体的工厂可生产多个产品
需要的类
（1）抽象产品类（作为个具体产品基类 、 包含共有的可显示自身产品信息的纯虚方法、 析构函数需要定义为虚函数（多态方面原因））
（2）具体产品类（继承抽象产品类）
（3）抽象工厂类（工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现）
（4）具体工厂类（继承于抽象工厂，实现多个创建对应具体产品对象的方式）
代码如下（示例）
#include <iostream>
class Clothing
{
public:
virtual void show() = 0;
virtual ~Clothing(){}
};
class Coat :public Clothing
{
void show()
{
std::cout << "I'm coat!" << std::endl;
}
};
class Shoes :public Clothing
{
void show()
{
std::cout << "I'm shoes!" << std::endl;
}
};
class ComplexFactory
{
public:
virtual Clothing* CreateCoat() = 0;
virtual Clothing* CreateShoes() = 0;
virtual ~ComplexFactory(){}
};
class ClothesFactory :public ComplexFactory
{
public:
Clothing* CreateCoat()
{
return new Coat();
}
Clothing* CreateShoes()
{
return new Shoes();
}
};
int main()
{
ComplexFactory* m_coatfactory = new ClothesFactory();
Clothing* m_coat = m_coatfactory->CreateCoat();
if (m_coat)
{
m_coat->show();
delete m_coat;
m_coat = NULL;
}
Clothing* m_shoes = m_coatfactory->CreateShoes();
if (m_shoes)
{
m_shoes->show();
delete m_shoes;
m_shoes = NULL;
}
}
输出结果
I'm coat!
I'm shoes!