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

1，设计模式

　　设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

2.设计模式原则

　　1）开闭原则（Open Close Principle）

　　　　开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码。

　　2）里氏代换原则（Liskov Substitution Principle）

　　　　里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LS里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

　　3）依赖倒转原则（Dependence Inversion Principle）

　　　　这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

　　4）接口隔离原则（Interface Segregation Principle）

　　　　使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

　　5）迪米特法则，又称最少知道原则（Demeter Principle）

　　　　最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

　　6）合成复用原则（Composite Reuse Principle）

　　　　合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。.

3.简单工厂模式

　　简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

　　例如：

　　　　有一家生产处理核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器，一定要显示地告诉生产工厂。

　　代码如下：

            #include <iostream>
            using namespace std;
            enum CTYPE {COREA,COREB};
            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:
                SingleCore* CreateSingleCore(enum CTYPE c)
                {
                    if(c == COREA)
                    {
                        cout << "Create Single Core A" << endl;
                        return new SingleCoreA;
                    }
                    else if(c == COREB)
                    {
                        cout << "Create Single Core B" << endl;
                        return new SingleCoreB;
                    }
                    else
                    
                        cout << "Don't have this Core" << endl;
                        return NULL;
                    }
                }
            };

            int main()
            {
                    Factory m;
                    SingleCore* p = m.CreateSingleCore(COREA);
                    p->Show();
                    p = m.CreateSingleCore(COREB);
                    p->Show();
            }     

　　缺点：

　　　　就是当需要增加新的处理器核类型式，需要修改工厂类，违反了开放封闭原则：可扩展，但不可修改。

4.工厂方法模式：

　　是指定义一个用于创建对象的接口，让子类决定实例化哪个类。将创建过程延迟到子类进行。

　　例如：

　　生产处理器的厂家，决定再开设一个工厂专门用来生产B型号的单核,一个工厂用来生产A型号的单核。这时客户要A型号的核，就找A工厂要；B型号的，找B工厂要;

　　代码如下：

            #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();
            }    

　　缺点:

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

5.抽象工厂模式：

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

　　例如：

　　　　这家公司的技术不断发展，现在可以生产多核的处理器，具体方法：还是开设两个工厂分别用来生产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();
            }