C++工厂模式与原型模式

先介绍一下简单工厂模式，就是有一个抽象类Mouse和一个工厂类，在工厂里面做判断，来确定子对象。下面这个是简单工厂模式

#include <iostream>
#include <string>
#include <memory>

class Mouse{
public:
    virtual void show()const = 0;
};

class HuaWeiMouse : public Mouse{
public:
    void show()const override{
        std::cout << "HuaWeiMouse " << std::endl;
    }
};

class XiaoMiMouse : public Mouse{
public:
    void show()const override{
        std::cout << "XiaoMiMouse " << std::endl;
    }
};

class Factory{
public:
    void MouseShow(const std::string& s){
        std::unique_ptr<Mouse> ptr;
        if(s == "HuaWei"){
            ptr = std::make_unique<HuaWeiMouse>();
        }
        else if(s == "XiaoMi")
        {
             ptr = std::make_unique<XiaoMiMouse>();
        }
        else{
            ptr = std::make_unique<HuaWeiMouse>();
        }
        ptr->show();
    }
};

int main(){
    Factory f;
    f.MouseShow("HuaWei");
    f.MouseShow("XiaoMi");

    return 0;
}

一般的工厂模式就是把Factory的show函数中的if去掉，因为如果再来十多个厂生产鼠标又要加很多if分支，也破坏了开放-封闭原则。

工厂模式

#include <iostream>
#include <string>
#include <memory>
using namespace std;
class Mouse {
public:
    Mouse() = default;
    virtual void show()const = 0;
};

class HuaWeiMouse : public Mouse {
public:
    HuaWeiMouse() = default;
    void show()const override {
        std::cout << "HuaWeiMouse " << std::endl;
    }
};

class XiaoMiMouse : public Mouse {
public:
    XiaoMiMouse() = default;
    void show()const override {
        std::cout << "XiaoMiMouse " << std::endl;
    }
};


class Factory {
public:
    virtual unique_ptr<Mouse> create() = 0;
protected:
    unique_ptr<Mouse> defaultCreate() {//给一个默认值
        return make_unique<HuaWeiMouse>(HuaWeiMouse());
    }
};
class HuaWeiFactory : public Factory {
public:
    virtual unique_ptr<Mouse> create()override {
        return defaultCreate();
    }
};
class XiaoMiFactory : public Factory {
public:
    virtual unique_ptr<Mouse> create()override {
        return make_unique<XiaoMiMouse>(XiaoMiMouse());
    }
};
int main() {
    Factory* f = new HuaWeiFactory();
    auto ptr = f->create();
    ptr->show();
    return 0;
}

把烦人的if语句就去掉了，新增加create纯虚函数，用到那个品牌就创建那个品牌的对象，利用智能指针防止内存泄露，尽管是个小demo也想着内存泄露的事情吧。当然了有些时候纯虚函数也想有默认代码，可以像我这样写个默认函数调用。也可以写成虚函数，这样也保留了默认代码还不用新开一个函数，但是这就会有一个问题，本来不想调用默认的虚函数，还忘记了override虚函数调用虚函数的默认代码就会产生问题，所以用新开一个函数来处理也不错，但是也有人觉得这样太浪费命名了，建议在基类也写个纯虚函数的默认值，当然也是可以的了，我是不喜欢所以没有这样做，effective C++第35条款有提到，没太明白可以去参考下那本书。

抽象工厂，我的理解就是工厂的集合，比如现在是在造鼠标，如果小米和华为造手机，那可以新增一个createPhone函数，表示造手机而不用新开一个工厂了，只需要添加新Phone的基类和子类即可。

#include <iostream>
#include <string>
#include <memory>
using namespace std;
class Mouse {
public:
    Mouse() = default;
    virtual void show()const = 0;
};

class HuaWeiMouse : public Mouse {
public:
    HuaWeiMouse() = default;
    void show()const override {
        std::cout << "HuaWeiMouse " << std::endl;
    }
};

class XiaoMiMouse : public Mouse {
public:
    XiaoMiMouse() = default;
    void show()const override {
        std::cout << "XiaoMiMouse " << std::endl;
    }
};

class Phone {
public:
    virtual void show() = 0;
};
class HuaWeiPhone :public Phone
{
public:
    virtual void show()override {
        cout << "HuaWeiPhone" << endl;
    }
};
class XiaoMiPhone :public Phone
{
public:
    virtual void show()override {
        cout << "XiaoMiPhone" << endl;
    }
};

class Factory {
public:
    virtual unique_ptr<Mouse> createMouse() = 0;
    virtual unique_ptr<Phone> createPhone() = 0;
protected:
    unique_ptr<Mouse> defaultCreateMouse() {//给一个默认值
        return make_unique<HuaWeiMouse>(HuaWeiMouse());
    }
    unique_ptr<Phone> defaultCreatPhone() {//给一个默认值
        return make_unique<HuaWeiPhone>(HuaWeiPhone());
    }
};
class HuaWeiFactory : public Factory {
public:
    virtual unique_ptr<Mouse> createMouse()override {
        return defaultCreateMouse();
    }
    virtual unique_ptr<Phone> createPhone()override {
        return defaultCreatPhone();
    }
};
class XiaoMiFactory : public Factory {
public:
    virtual unique_ptr<Mouse> createMouse()override {
        return make_unique<XiaoMiMouse>(XiaoMiMouse());
    }
    virtual unique_ptr<Phone> createPhone()override {
        return make_unique<XiaoMiPhone>(XiaoMiPhone());
    }
};
int main() {
    Factory* f = new HuaWeiFactory();
    auto ptr = f->createPhone();
    ptr->show();
    return 0;
}

原型模式，就是工厂模式给他合并起来，工厂模式也是创建一个类的对象，原型模式也是创建对象。什么时候创建对象？当使用者想保存他的状态的时候去使用,或者创建复杂的时候去使用这个

using namespace std;
class Mouse {
public:
	Mouse() = default;
	virtual void show()const = 0;
	virtual Mouse* clone() = 0;
};

class HuaWeiMouse : public Mouse {
public:
	HuaWeiMouse() = default;
	void show()const override {
		std::cout << "HuaWeiMouse " << std::endl;
	}
	Mouse* clone()override{
		return new HuaWeiMouse(*this);
	}
};

class XiaoMiMouse : public Mouse {
public:
	XiaoMiMouse() = default;
	void show()const override {
		std::cout << "XiaoMiMouse " << std::endl;
	}
	Mouse* clone()override {
		return new XiaoMiMouse(*this);
	}
};
class Use{
	Mouse* m_;
public:
	Use(Mouse* m):m_(m){}
	void show(){
		auto m = m_.clone();
		m.show();
	}
};
int main() {
	Use u(new HuaWeiMouse());
	u.show();
	return 0;
}