工厂模式

简单工厂模式

通过专门定义一个类来负责创建其他类的示例，被创建的实例通常有共同的父类。

简单工厂模式中的角色

1、工厂角色
      – 既然是工厂模式，那肯定得有个工厂。这是核心，他负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，用来创建所需的产品对象。
2、抽象角色
      – 简单工厂模式所创建的所有对象的父类，他负责描述所有实例所共有的公共接口。
3、具体产品角色
      – 简单工厂模式所创建的实例。

接下来上一个现实中的例子，比如你想喝咖啡，咖啡分很多种是吧，像是摩卡啊，卡布奇诺啊，拿铁啊，玛琪雅朵啊，其实说白了他们都有共同的原料那就是原浆咖啡，再加上不同的配方才变成现在的咖啡的。这里工厂就是咖啡机，用来做咖啡。看代码。

#include<iostream>
#include<string>
using namespace std;

//抽象角色
class Coffee
{
public:
    Coffee() {}
    virtual void get() = 0;
};

class Cappuccino : public Coffee
{
private:
    int coffee;
    int milk;
    int suger;
public:
    Cappuccino ()
    {
        coffee = 1;
        milk   = 1;
        suger  = 1;
    }
    virtual void get()
    {
        cout << "get Cappuccino "<<endl;
    }
};

class Latte : public Coffee
{
private:
    int coffee;
    int milk;
    int suger;
public:
    Latte ()
    {
        coffee = 1;
        milk   = 2;
        suger  = 2;
    }
    virtual void get()
    {
        cout << "get Latte "<<endl;
    }
};

class Mocha : public Coffee
{
private:
    int coffee;
    int milk;
    int suger;
public:
    Mocha ()
    {
        coffee = 3;
        milk   = 2;
        suger  = 2;
    }
    virtual void get()
    {
        cout << "get Mocha "<<endl;
    }
};

//简单工厂
class SimpleFactory
{
public:
    SimpleFactory() {}
    Coffee* create(const string& name)
    {
        if(name == "Cappuccino")
            return new Cappuccino;
        else if(name == "Latte")
            return new Latte;
        else if(name == "Mocha")
            return new Mocha;
        else
            return nullptr;
    }
};

int main(int argc, char *argv[])
{
    //网上新买了一个咖啡机
    SimpleFactory * Coffee_maker = new SimpleFactory();

    Coffee * coffee = nullptr;
    //想喝拿铁了,来一杯
    coffee = Coffee_maker->create("Cappuccino");
    coffee->get();
    delete coffee;
    coffee = nullptr;

    //想喝卡布奇诺了,来一杯
    coffee = Coffee_maker->create("Latte");
    coffee->get();
    delete coffee;
    coffee = nullptr;

    //想喝摩卡了,来一杯
    coffee = Coffee_maker->create("Mocha");
    coffee->get();
    delete coffee;
    coffee = nullptr;
    
    delete Coffee_maker;
    
    return 0;
}

虽然简单工厂模式实现起来不复杂，但是很可惜，这玩意并不符合标准设计模式的要求，所以他并不是标准设计模式。
为什么呀？想要改变功能我们得修改里面的代码啊。这不是破坏了原有的结构了吗。

---

来来来，真正的工厂模式来啦。
之前我们是使用一个工厂类来创建我们所需要的产品对象，这样做虽然方便，但是难免给我们带来了一个问题，当我们想创建新的产品对象时（之前没有的）我们居然要修改工厂里的代码。说明工厂类的耦合度还是太高了。那我们该怎么去给工厂类进行解耦呢？

很简单，工厂也作为一个抽象的父类，当我们需要Cappuccino 的时候，我们就弄一个Cappuccino 工厂，这个工厂专门生产Cappuccino 。其他产品也是用这种生产方式生产，我们生产什么使用。

来来来，店小二上代码

#include<iostream>
#include<string>
using namespace std;

//抽象角色
class Coffee
{
public:
    Coffee() {}
    virtual void get() = 0;
};

class Cappuccino : public Coffee
{
private:
    int coffee;
    int milk;
    int suger;
public:
    Cappuccino ()
    {
        coffee = 1;
        milk   = 1;
        suger  = 1;
    }
    virtual void get()
    {
        cout << "get Cappuccino "<<endl;
    }
};

class Latte : public Coffee
{
private:
    int coffee;
    int milk;
    int suger;
public:
    Latte ()
    {
        coffee = 1;
        milk   = 2;
        suger  = 2;
    }
    virtual void get()
    {
        cout << "get Latte "<<endl;
    }
};

class Mocha : public Coffee
{
private:
    int coffee;
    int milk;
    int suger;
public:
    Mocha ()
    {
        coffee = 3;
        milk   = 2;
        suger  = 2;
    }
    virtual void get()
    {
        cout << "get Mocha "<<endl;
    }
};

//抽象工厂
class CoffeeFactory
{
public:
    CoffeeFactory() {}
    virtual Coffee* create() = 0;
};

class CappuccinoFactory : public CoffeeFactory
{
public:
    CappuccinoFactory() {}
    virtual Coffee* create()
    {
        return new Cappuccino;
    }
};

class LatteFactory : public CoffeeFactory
{
public:
    LatteFactory() {}
    virtual Coffee* create()
    {
        return new Latte;
    }
};

class MochaFactory : public CoffeeFactory
{
public:
    MochaFactory() {}
    virtual Coffee* create()
    {
        return new Mocha;
    }
};

int main(int argc, char *argv[])
{
    CoffeeFactory * Coffee_maker = nullptr;
    Coffee * coffee = nullptr;

    //想喝拿铁了,来一杯
    Coffee_maker = new LatteFactory();
    coffee = Coffee_maker->create();
    coffee->get();
    delete coffee;
    delete Coffee_maker;
    coffee = nullptr;
    Coffee_maker = nullptr;

    //想喝卡布奇诺了,来一杯
    Coffee_maker = new CappuccinoFactory();
    coffee = Coffee_maker->create();
    coffee->get();
    delete coffee;
    delete Coffee_maker;
    coffee = nullptr;
    Coffee_maker = nullptr;

    //想喝摩卡了,来一杯
    Coffee_maker = new MochaFactory();
    coffee = Coffee_maker->create();
    coffee->get();
    delete coffee;
    delete Coffee_maker;
    coffee = nullptr;
    Coffee_maker = nullptr;

   // delete Coffee_maker;
    return 0;
}