工厂模式

工厂模式

工厂模式：工厂设计模式，顾名思义，就是用来生产对象的，在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦

简单工厂模式

简单工厂模式定义了一个创建对象的类，由这个类来决定创建出哪一种产品类的实例。

在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。

class Factorycal
{
public:
    static cal *create_obj(char chars)
    {  
        cal *cal;
        switch(chars)
        {
            case '+':
                cal =  new cal_add();
                break;
            case '-':
                cal =  new cal_sub();
                break;
            case '*':
                cal = new cal_mul();
                break;
            case '/':
                cal =  new cal_div();
                break;
        }

        return cal;
    }
};

工厂模式

将工厂提取成一个接口或抽象类，具体生产什么产品由子类决定

工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。
当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

class abs_Factorycal
{
public:
    virtual cal *create_obj() = 0;
};

class factory_add : public abs_Factorycal
{
public:
    cal *create_obj()
    {
        return new cal_add();
    }
};

class factory_sub : public abs_Factorycal
{
public:
    cal *create_obj()
    {
        return new cal_sub();
    }
};

class factory_mul : public abs_Factorycal
{
public:
    cal *create_obj()
    {
        return new cal_mul();
    }
};

class factory_div : public abs_Factorycal
{
public:
    cal *create_obj()
    {
        return new cal_div();
    }
};

int main()
{
    switch(op)
    {
        case '+':
            factory = new factory_add();
            break;
        case '-':
            factory = new factory_sub();
            break;
        case '*':
            factory = new factory_mul();
            break;
        case '/':
            factory = new factory_div();
            break;
    }
}

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种软件开发设计模式。抽象工厂模式提供了一种方式，可以将一组具有同一主题的单独的工厂封装起来。如果比较抽象工厂模式和工厂模式，我们不难发现前者只是在工厂模式之上增加了一层抽象的概念。抽象工厂是一个父类工厂，可以创建其它工厂类。所以我们也叫它 “工厂的工厂”。

class create_factory
{
public:
    static abs_Factorycal *create_factory_func(char op)
    {
        switch(op)
        {
            case '+':
                return new factory_add();
                break;
            case '-':
                return new factory_sub();
                break;
            case '*':
                return new factory_mul();
                break;
            case '/':
                return new factory_div();
                break;
        }
    }
};

以上三种工厂模式的区别：
简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）
工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

对象的动态创建

//对象的动态创建
template <typename T>
class dyn_create_obj
{
public:
    template <typename obj>
    void register_type(char type)
    {
        function<T *()> func = [](){return new obj();};

        if (m.find(type) == m.end())
        {
            m.emplace(type, func);
        }
        else
        {
            throw("type已存在");
        }
        
    }

    T *get_obj(char type)
    {
        function<T *()> func;

        if(m.find(type) != m.end())
        {
            func = m[type];
            return func();
        }
        else
        {
            throw("type不存在");
        }
        
    }
private:
    map<const char, function<T *()>> m;
};

int main()
{
    cal *cal1;
    int a = 3;
    int b = 4;

    char op;

    cin >> op;

    dyn_create_obj<cal> dyn_obj;

    dyn_obj.register_type<cal_add>('+');
    dyn_obj.register_type<cal_sub>('-');
    dyn_obj.register_type<cal_mul>('*');
    dyn_obj.register_type<cal_div>('/');

    cal1 = dyn_obj.get_obj(op);
}