设计模式：工厂模式

简单工厂模式

工厂模式就是一个工厂类像流水线一样可以生产诸多的商品。

代码示例

#include <iostream>
using std::cout;
enum class Type : char
{
    Snake,
    Monkey
};

class AbstractAnimal
{
public:
    AbstractAnimal() = default;
    virtual void print() = 0;
    virtual ~AbstractAnimal() {}
};

class Monkey : public AbstractAnimal
{
public:
    void print() override
    {
        cout << "i am monkey!!!\n";
    }
    ~Monkey() override {}
};

class Snake : public AbstractAnimal
{
public:
    void print() override
    {
        cout << "i am snake!!!sisisisis!!!\n";
    }
    ~Snake() override {}
};

class Factory
{
public:
    virtual AbstractAnimal* creatAnimal(Type type)
    {
        switch(type)
        {
            case Type::Monkey:
            return new Monkey;
            break;
            case Type::Snake:
            return new Snake;
            break;
            default:
            break;
        }
        return nullptr;
    }
};

int main()
{
    Factory myFactory;
    auto obj = myFactory.creatAnimal(Type::Monkey);
    obj->print();
    auto obj2 = myFactory.creatAnimal(Type::Snake);
    obj2->print();
    return 0;
}

注意：设计模式的精髓就是多态，俗话说的好，妹有多态就妹有设计模式。

简单工厂适合于确定数量的产品，一个工厂就能够生产诸多产品。

存在问题

简单工厂当需要添加商品或者增加功能时，就需要修改类内部的元素，打破开放封闭原则。

工厂模式

解决简单工厂一个工厂生产诸多商品，不易于添加商品的情况。

工厂模式，使用一个抽象工厂类，为每个产品添加对应的抽象工厂类，这样工厂和产品具有一对一的关系，工厂就可以源源不断的生产某种特定商品。

现在：每种商品都有一个共同的抽象商品基类；每种工厂都具有一个共同的抽象工厂基类。

代码示例

#include <iostream>
using std::cout;

class AbstractAnimal
{
public:
    AbstractAnimal() = default;
    virtual void print() = 0;
    virtual void price() = 0;
    virtual ~AbstractAnimal() {}
};

class Monkey : public AbstractAnimal
{
public:
    Monkey() = default;
    void print() override
    {
        cout << "I am Monkey\n" ;
    }
    void price() override
    {
        cout << "Monkey doesn't sales!\n";
    }
};

class Snake : public AbstractAnimal
{
public:
    Snake() = default;
    void print() override
    {
        cout << "I am Snake!\n" ;
    }
    void price() override
    {
        cout << "Snake ????\n";
    }
};

class AbstractFartory   //抽象工厂类
{
public:
    virtual AbstractAnimal* visitAnimal() = 0 ;
    virtual ~AbstractFartory(){}
};

class MonkeyFactory : public AbstractFartory
{
public:
    AbstractAnimal* visitAnimal() override
    {
        return new Monkey;
    }
    ~MonkeyFactory() {}
};

class SnakeFactory : public AbstractFartory
{
public:
    AbstractAnimal* visitAnimal() override
    {
        return new Snake;
    }
    ~SnakeFactory() {}
};

int main()
{
    AbstractFartory* fac = new SnakeFactory;   //基类指针指向派生类对象。构成多态
    auto ani = fac->visitAnimal();    //基类指针指向派生类对象 。构成多态
    ani->price();
    ani->print();
    delete ani;
    delete fac;
    return 0;
}

当更加复杂时，比如动物具有不同的体重 身高 时，更加复杂，就需要抽象工厂模式。

抽象工厂模式

在工厂模式上，猴子和蛇确定了，但更细致的是，怎么判断一个动物是猴子还是蛇？那么就需要设置科目和种（不清楚动物的分类）来进行判断，由于更加复杂，所以引入抽象工厂模式。

代码示例

#include <iostream>
#include <string>
using std::cout;
using std::string;

//种
class subject
{
public:
    virtual string getSubject() = 0;
    virtual ~subject() {}
};

//灵长类
class ghostLong : public subject
{
public:
    string getSubject() override
    {
        return "灵长类动物！";
    }
};

//爬行类
class reptile : public subject
{
public:
    string getSubject() override
    {
        return "爬行类动物！";
    }
};

class type
{
public:
    virtual string getType() = 0;
    virtual ~type(){}
};

class mammals : public type
{
public: 
    string getType()
    {
        return "哺乳纲";
    }
};

//蛇 双目亚纲
class twoEyes : public type
{
public: 
    string getType()
    {
        return "双目亚纲";
    }
};

//组合关系，析构animal类时把成员申请的空间也回收掉
class animal
{
public:
    //传参时传递不同的子类对象，得到的动物也就不同
    animal(subject* subject,type* type)
    :m_subject(subject),m_type(type){}
    string getAnimal()
    {
        string info =  m_subject->getSubject() + m_type->getType();
        return info;
    }
    ~animal()
    {
        delete m_subject;
        delete m_type;
    }
private:
    subject* m_subject;
    type* m_type;
};

//抽象工厂类 通过工厂得到一个动物
class AbstractFactory  
{
public:
    virtual animal* visitAnimal() = 0;
    virtual ~AbstractFactory(){}
};

class MonkeyFactory : public AbstractFactory
{ 
    animal* visitAnimal() override
    {
        animal* Monkey = new animal(new ghostLong,new mammals);  //传参
        cout << "这是一只猴子！\n";
        return  Monkey;
    }
};


class SnakeFactory : public AbstractFactory
{ 
    animal* visitAnimal() override
    {
        animal* Snake = new animal(new reptile,new twoEyes);  //传参
        cout << "这是一只猴子！\n";
        return  Snake;
    }
};

int main()
{
    AbstractFactory* myFactory = new MonkeyFactory;
    animal* mymonkey = myFactory->visitAnimal();
    cout << mymonkey->getAnimal() << "\n";
    return 0;
}