工厂模式

#include <iostream>
using namespace std;
class SingleCore {
public:
    virtual void Show() = 0;
};

class SingleCoreA :public SingleCore {
public:
    void Show() { cout << "Single Core A" << endl; }
};

class SingleCoreB :public SingleCore {
public:
    void Show() { cout << "Single Core B" << endl; }
};

class Factory {
public:
    virtual SingleCore* CreateSingleCore() = 0;
};

class FactoryA :public Factory {
public:
    SingleCore* CreateSingleCore()
    {
        cout << "Create SingleCore A" << endl;
        return new SingleCoreA();
    }
};

class FactoryB :public Factory {
public:
    SingleCore* CreateSingleCore()
    {
        cout << "Create SingleCore B" << endl;
        return new SingleCoreB();
    }
};

int main()
{
    FactoryA m;
    SingleCore* p = m.CreateSingleCore();
    p->Show();
    FactoryB n;
    p = n.CreateSingleCore();
    p->Show();
}

　缺点: 每增加一个新产品就需要，增加一个对象的工厂。

 

抽象工厂模式：是指定义一个创建一些列相关或相互依赖的对象接口，而无需指定它们具体的类。

例如：这家公司的技术不断发展，现在可以生产多核的处理器，具体方法：还是开设两个工厂分别用来生产A,B两种型号的处理器。
代码如下：

#include <iostream>
using namespace std;
class SingleCore {
public:
    virtual void Show() = 0;
};

class SingleCoreA : public SingleCore {
public:
    void Show() { cout << " SingleCoreA" << endl; }
};

class SingleCoreB : public SingleCore {
public:
    void Show() { cout << " SingleCoreA" << endl; }
};

class SingleCoreB : public SingleCore
{
public:
    void Show() { cout << "SingleCoreB" << endl; }
};

class MultiCore {
public:
    virtual void Show() = 0;
};

class MultiCoreA : public MultiCore {
public:
    void Show() { cout << "MultiCoreA" << endl; }
};
class MultiCoreB : public MultiCore
{
public:
    void Show() { cout << "MultiCoreB" << endl; }
};

class CoreFactory {
public:
    virtual SingleCore* createSingleCore() = 0;
    virtual MultiCore* createMultiCore() = 0;
};

class CoreFactoryA :public CoreFactory {
public:
    SingleCore* createSingleCore()
    {
        cout << "create SingleCoreA" << endl;
        return new SingleCoreA();
    }
    MultiCore* createMultiCore()
    {
        cout << "create MultiCoreA" << endl;
        return new MultiCoreA();

    }
};
class CoreFactoryB : public CoreFactory
{
public:
    SingleCore* createSingleCore()
    {
        cout << "create SingleCoreB" << endl;
        return new SingleCoreB();
    }
    MultiCore* createMultiCore()
    {
        cout << "create MultiCoreB" << endl;
        return new MultiCoreB();
    }
};

int main()
{
    CoreFactoryB Fcb;
    SingleCore* core = Fcb.createSingleCore();
    MultiCore* Mcore = Fcb.createMultiCore();
    core->Show();
    Mcore->Show();
    CoreFactoryA Fca;
    core = Fca.createSingleCore();
    Mcore = Fca.createMultiCore();
    core->Show();
    Mcore->Show();
}

参考资料：

• C++------简单工厂模式，工厂方法模式和抽象工厂模式