目录
工厂模式（Factory Pattern）
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法是一个类的实例化延迟到其子类。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象
介绍：
意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
主要解决：主要解决接口选择的问题。
何时使用：我们明确地计划不同条件下创建不同实例时。
如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
关键代码：创建过程在其子类执行。
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
代码实现：
工厂模式还分为简单工厂模式和多工厂模式；
简单工厂模式：
所谓简单工厂模式就是指在这个模块中我们仅仅需要一个工厂,如示例一，我们仅仅需要一个Factory对象，就能够生产出Rectangle、Square等图形，当然我们可以更加简化，仅需要调用Factory内的create函数就能够生产产品，而不需要实例化出Factory对象，因此我们只需要将create方法设置为static方法即可，如示例二所示。
示例一：
#pragma once
#include<iostream>
enum type{
rectangle = 0,
square
};
class Shape{
public:
virtual void draw() = 0;
};
class Rectangle :public Shape{
public:
void draw()
{
std::cout << "draw Rectangle" << std::endl;
}
};
class Square :public Shape{
public:
void draw()
{
std::cout << "draw Square" << std::endl;
}
};
class Factory{
public:
Shape* create(type tp)
{
if (tp == rectangle)
{
return new Rectangle;
}
else if (tp == square)
{
return new Square;
}
else
{
return nullptr;
}
}
};示例二：
#pragma once
#include<iostream>
enum type{
rectangle = 0,
square
};
class Shape{
public:
virtual void draw() = 0;
};
class Rectangle :public Shape{
public:
void draw()
{
std::cout << "draw Rectangle" << std::endl;
}
};
class Square :public Shape{
public:
void draw()
{
std::cout << "draw Square" << std::endl;
}
};
class Factory{
public:
static Shape* create(type tp);
};
Shape* Factory::create(type tp)
{
if (tp == rectangle)
{
return new Rectangle;
}
else if (tp == square)
{
return new Square;
}
else
{
return nullptr;
}
}示例一的测试：
void Test2()
{Factory f;
Shape* re=f.create(rectangle);
re->draw();
Shape* sq =f.create(square);
sq->draw();
}示例二的测试：
void Test2()
{
Shape* re=Factory::create(rectangle);
re->draw();
Shape* sq =Factory::create(square);
sq->draw();
}
观察上面的代码，我们也能发现，当我们增加一个图形的时候，我们需要修改工厂类，这不符合开闭原则；但是在产品不变的情况下，简单工厂模式也是一个非常实用的设计模式。
多工厂模式：
每个产品都有一个专属于自己的生产工厂，每个生产工厂负责创建对应的产品，这符合单一职责原则；如下面的代码所示：
class shape {
virtual void draw() =0;
};
class Rectangle :public shape{
public:
void draw()
{
std::cout << "draw Rectangle" << std::endl;
}
};
class Square :public shape{
public:
void draw()
{
std::cout << "draw Square" << std::endl;
}
};
class Factory{
public:
virtual shape* Create() = 0;
};
class RectangleFactory:public Factory{
public:
Rectangle* Create()
{
return new Rectangle;
}
};
class SquareFactory{
public:
Square* Create()
{
return new Square;
}
};RectangleFactory rf;
Rectangle* r = rf.Create();
r->draw();
SquareFactory sf;
Square* s = sf.Create();
s->draw();
每个产品对应一个工厂，创建的类职责清晰，而且结构简单，但是可扩展性和可维护性带来了一定的影响，每增加一个产品，就需要增加一个对应的工厂；
注：如果本篇博客有任何错误和建议，欢迎伙伴们留言，你快说句话啊！