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