c++设计模式：工厂模式

 策略模式和工厂模式有什么区别呢？

简单工厂模式的实例化由工厂类来实现，用户只需要传递一个条件，由工厂生产出相应的类；

策略模式需要用户自己实例化类，传递的是实例化的对象。

1.由于上一篇的策略，我们可以看出来，如果有更多的算法法类，我们客户端要手动添加，很麻烦。因此通过添加一个工厂类，上层只传递一个字符串就可以实现创建不同的算法。这样的我们可以结合策略模式和工厂模式的思想。

//简单工厂模式
class drink
{
public:
    virtual void getResult(){}
};
class caffe:public drink
{
public:
    void getResult(){ cout << "caffe" << endl; }
};
class coke :public drink
{
public:
    void getResult(){ cout << "coke" << endl; }
};
class factory
{
public:
    static drink* create(int a){
        drink *p=0;
        switch (a)
        {
        case 0:
            p = new caffe();
            break;
        case 1:
            p = new coke();
            break;
        default:
            break;
        }
        return p;
    }
};
int main()
{
    drink* cup;
    cup = factory::create(1);
    cup->getResult();
    return 0;
}
策略模式

 

//策略模式
class strategy
{
public:
    virtual void getResult(){}
};
class steal :public strategy
{
public:
    string target;
    steal(string name){ target = name; }//构造函数
    void getResult(){ cout << "偷" << target << endl; }
};
class cheat :public strategy
{
public:
    string target;
    cheat(string name){ target = name; }//构造函数
    void getResult(){ cout << "骗" << target << endl; }
};
class context
{
public:
    strategy* m;
    context(strategy* a){
        m = a;
    }
    void getResult(){
        m->getResult();
    }
};
int main()
{
    int a = 0;
    context* xingdongdong=0;
    switch (a)
    {
    case 0:
        xingdongdong = new context(new cheat("赵阳"));
        break;
    case 1:
        xingdongdong = new context(new steal("钱东海"));
        break;
    default:
        break;
    }
    xingdongdong->getResult();
    return 0;
}
策略模式我能看到的好处是对对象有很大的自主权，可以指定参数（“赵阳”），但是总感觉多此一举，我为什么非要通过你context实例化，我直接实例化不就好了吗？

简单工厂模式与策略模式的结合

//简单工厂模式和策略模式结合
class strategy
{
public:
    virtual void getResult(){}
};
class steal :public strategy
{
public:
    void getResult(){ cout << "偷" <<  endl; }
};
class cheat :public strategy
{
public:
    void getResult(){ cout << "骗" <<  endl; }
};
class context
{
public:
    strategy* m;
    context(int a){
        switch (a)
        {
        case 0:
            m = new cheat();
            break;
        case 1:
            m = new steal();
            break;
        default:
            break;
        }
    }
    void getResult(){
        m->getResult();
    }
};
int main()
{
    context* xingdongdong = new context(1);
    xingdongdong->getResult();
    return 0;
}
优点：

1、不用自己实例化生产对象，只需要传递一个参数就可以通过工厂类完成

2、用户不需要知道生产对象的存在，只需要操作工厂类就可以

 

另外，我项目上用的严格来说不算设计模式，只是简单的多态，由于需要将采集的图像以两种格式存储下来，一种是单帧的bmp格式，另一种是raw连续帧大文件，两种方式只是存储格式和方法有差异，因此可以继承自同一个父类。

class DataSaverStrategy
{
};
class DataSaverStrategyA :public DataSaverStrategy
{

};
class DataSaverStrategyB :public DataSaverStrategy
{

};
int main()
{
    int a = 0;
    DataSaverStrategy *p;
    switch (a)
    {
    case 0:
        p = new DataSaverStrategyA();
        break;
    case 1:
        p = new DataSaverStrategyB();
        break;
    default:
        break;
    }
    return 0;
}

2.简单工厂模式和抽象工厂模式

简单：一个工厂负责多个产品。

抽象：一个工厂负责多个产品，但两个产品实现同一个功能，举个例子两个算法实现对比度增强，这个时候就可以把这个产品类抽象出来，由两个具体算法来继承。