简单工厂模式和工厂方法模式

我就是我 2022-04-11 04:19 186阅读 0赞

\[color=red\]\[b\]  
简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。  
  
一般多个产品只有一个工厂类实现控制。  
\[/b\]\[/color\]  
  
\[img\]http://dl2.iteye.com/upload/attachment/0091/6096/8721053b-0b3a-3ffc-ba99-9fbdc6402b3c.png\[/img\]

//SimapleFactoryPattern.h
    
    #ifndef SIMPLE_FACTORY_PATTERN_H
    #define SIMPLE_FACTORY_PATTERN_H
    
    #include <Windows.h>
    
    namespace SimpleFactoryPattern
    {
       
        // Base Class
        //
        class Operation
        {
       
        public:
            Operation();
            virtual ~Operation();
    
            virtual double GetResoult() = 0;
    
        public:
            double m_fNumberA;
            double m_fNumberB;
        };
    
    
        //
        class OperationAdd : public Operation
        {
       
        public:
            OperationAdd();
            virtual ~OperationAdd();
    
            virtual double GetResoult();
        };
    
        //
        class OperationSub : public Operation
        {
       
        public:
            OperationSub();
            virtual ~OperationSub();
    
            virtual double GetResoult();
        };
    
        //
        class OperationMul : public Operation
        {
       
        public:
            OperationMul();
            virtual ~OperationMul();
    
            virtual double GetResoult();
        };
    
        //
        class OperationDiv : public Operation
        {
       
        public:
            OperationDiv();
            virtual ~OperationDiv();
    
            virtual double GetResoult();
        };
    
    
        //
        class OperationFactory
        {
       
        public:
            OperationFactory();
            ~OperationFactory();
    
            static Operation* CreateOperate(char chType)
            {
       
                Operation* pTempOp = NULL;
    
                switch(chType)
                {
       
                case '+': pTempOp = new OperationAdd(); break;
                case '-': pTempOp = new OperationSub(); break;
                case '*': pTempOp = new OperationMul(); break;
                case '/': pTempOp = new OperationDiv(); break;
                default: break;
                }
                return pTempOp;
            }
        };
    
    
        //
        void SimpleFactoryPattern_Test();
    
    }
    
    #endif

#include "SimpleFactoryPattern.h"
    #include <iostream>
    using namespace std;
    
    namespace SimpleFactoryPattern
    {
       
        //
        Operation::Operation()
        {
       
        }
        Operation::~Operation()
        {
       
        }
    
        //
        OperationAdd::OperationAdd()
        {
       
        }
        OperationAdd::~OperationAdd()
        {
       
        }
        double OperationAdd::GetResoult()
        {
       
            return m_fNumberA+m_fNumberB;
        }
    
        //
        OperationSub::OperationSub()
        {
       
        }
        OperationSub::~OperationSub()
        {
       
        }
        double OperationSub::GetResoult()
        {
       
            return m_fNumberA-m_fNumberB;
        }
    
        //
        OperationMul::OperationMul()
        {
       
        }
        OperationMul::~OperationMul()
        {
       
        }
        double OperationMul::GetResoult()
        {
       
            return m_fNumberA*m_fNumberB;
        }
    
        //
        OperationDiv::OperationDiv()
        {
       
        }
        OperationDiv::~OperationDiv()
        {
       
        }
        double OperationDiv::GetResoult()
        {
       
            return m_fNumberA/m_fNumberB;
        }
    
        //
        OperationFactory::OperationFactory()
        {
       
        }
        OperationFactory::~OperationFactory()
        {
       
        }
    
        //
        void SimpleFactoryPattern_Test()
        {
       
            Operation* pCurOP = NULL;
            pCurOP = OperationFactory::CreateOperate('+');
    
            pCurOP->m_fNumberA = 1;
            pCurOP->m_fNumberB = 2;
    
            double fResoult = pCurOP->GetResoult();
    
            cout << fResoult;
    
            delete pCurOP;
            pCurOP = NULL;
        }
    }

\[color=red\]\[b\]  
工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，悬着判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是改工厂类，而现在是修改客户端!  
一般来说，每一个产品都对应一个工厂类。  
\[/b\]\[/color\]  
  
\[img\]http://dl2.iteye.com/upload/attachment/0091/6108/b23b1d4c-366b-3064-b7a2-6f19164ae854.png\[/img\]

//FactoryMethodPattern.h
    
    #ifndef FACTORY_METHOD_PATTERN_H
    #define FACTORY_METHOD_PATTERN_H
    
    #include <Windows.h>
    
    namespace FactoryMethodPattern
    {
       
        // Base Class
        //
        class Operation
        {
       
        public:
            Operation();
            virtual ~Operation();
    
            virtual double GetResoult() = 0;
    
        public:
            double m_fNumberA;
            double m_fNumberB;
        };
    
    
    //     //
    //     class OperationAdd : public Operation
    //     {
       
    //     public:
    //         OperationAdd();
    //         virtual ~OperationAdd();
    // 
    //         virtual double GetResoult();
    //     };
    // 
    //     //
    //     class OperationSub : public Operation
    //     {
       
    //     public:
    //         OperationSub();
    //         virtual ~OperationSub();
    // 
    //         virtual double GetResoult();
    //     };
    // 
    //     //
    //     class OperationMul : public Operation
    //     {
       
    //     public:
    //         OperationMul();
    //         virtual ~OperationMul();
    // 
    //         virtual double GetResoult();
    //     };
    // 
    //     //
    //     class OperationDiv : public Operation
    //     {
       
    //     public:
    //         OperationDiv();
    //         virtual ~OperationDiv();
    // 
    //         virtual double GetResoult();
    //     };
    
    
        //
        class IFactory
        {
       
        public:
            IFactory();
            ~IFactory();
    
            virtual Operation* CreateOperate() = 0;
        };
    
    //     class AddFactory : public IFactory
    //     {
       
    //     public:
    //         AddFactory();
    //         virtual ~AddFactory();
    // 
    //         virtual Operation* CreateOperate();
    //     };
    //     class SubFactory: public IFactory
    //     {
       
    //     public:
    //         SubFactory();
    //         virtual ~SubFactory();
    // 
    //         virtual Operation* CreateOperate() ;
    //     };
    //     class MulFactory : public IFactory
    //     {
       
    //     public:
    //         MulFactory();
    //         virtual ~MulFactory();
    // 
    //         virtual Operation* CreateOperate() ;
    //     };
    //     class DivFactory : public IFactory
    //     {
       
    //     public:
    //         DivFactory();
    //         virtual ~DivFactory();
    // 
    //         virtual Operation* CreateOperate() ;
    //     };
    
    
        //
        void FactoryMethodPattern_Test();
    
    }
    
    #endif

#include "FactoryMethodPattern.h"
    #include <iostream>
    using namespace std;
    
    namespace FactoryMethodPattern
    {
       
        //
        class OperationAdd : public Operation
        {
       
        public:
            OperationAdd();
            virtual ~OperationAdd();
    
            virtual double GetResoult();
        };
    
        //
        class OperationSub : public Operation
        {
       
        public:
            OperationSub();
            virtual ~OperationSub();
    
            virtual double GetResoult();
        };
    
        //
        class OperationMul : public Operation
        {
       
        public:
            OperationMul();
            virtual ~OperationMul();
    
            virtual double GetResoult();
        };
    
        //
        class OperationDiv : public Operation
        {
       
        public:
            OperationDiv();
            virtual ~OperationDiv();
    
            virtual double GetResoult();
        };
    
        class AddFactory : public IFactory
        {
       
        public:
            AddFactory();
            virtual ~AddFactory();
    
            virtual Operation* CreateOperate();
        };
        class SubFactory: public IFactory
        {
       
        public:
            SubFactory();
            virtual ~SubFactory();
    
            virtual Operation* CreateOperate() ;
        };
        class MulFactory : public IFactory
        {
       
        public:
            MulFactory();
            virtual ~MulFactory();
    
            virtual Operation* CreateOperate() ;
        };
        class DivFactory : public IFactory
        {
       
        public:
            DivFactory();
            virtual ~DivFactory();
    
            virtual Operation* CreateOperate() ;
        };
    
    
        //
        Operation::Operation()
        {
       
        }
        Operation::~Operation()
        {
       
        }
    
        //
        OperationAdd::OperationAdd()
        {
       
        }
        OperationAdd::~OperationAdd()
        {
       
        }
        double OperationAdd::GetResoult()
        {
       
            return m_fNumberA+m_fNumberB;
        }
    
        //
        OperationSub::OperationSub()
        {
       
        }
        OperationSub::~OperationSub()
        {
       
        }
        double OperationSub::GetResoult()
        {
       
            return m_fNumberA-m_fNumberB;
        }
    
        //
        OperationMul::OperationMul()
        {
       
        }
        OperationMul::~OperationMul()
        {
       
        }
        double OperationMul::GetResoult()
        {
       
            return m_fNumberA*m_fNumberB;
        }
    
        //
        OperationDiv::OperationDiv()
        {
       
        }
        OperationDiv::~OperationDiv()
        {
       
        }
        double OperationDiv::GetResoult()
        {
       
            return m_fNumberA/m_fNumberB;
        }
    
        //
        IFactory::IFactory()
        {
       
        }
        IFactory::~IFactory()
        {
       
        }
    
        //
        AddFactory::AddFactory()
        {
       
        }
        AddFactory::~AddFactory()
        {
       
        }
        Operation* AddFactory::CreateOperate()
        {
       
            return new OperationAdd();
        }
    
        //
        SubFactory::SubFactory()
        {
       
        }
        SubFactory::~SubFactory()
        {
       
        }
        Operation* SubFactory::CreateOperate()
        {
       
            return new OperationSub();
        }
    
        //
        MulFactory::MulFactory()
        {
       
        }
        MulFactory::~MulFactory()
        {
       
        }
        Operation* MulFactory::CreateOperate()
        {
       
            return new OperationMul();
        }
    
        //
        DivFactory::DivFactory()
        {
       
        }
        DivFactory::~DivFactory()
        {
       
        }
        Operation* DivFactory::CreateOperate()
        {
       
            return new OperationDiv();
        }
    
        //
        void FactoryMethodPattern_Test()
        {
       
            IFactory* pCurFactory = new AddFactory();
            Operation* pCurOp = pCurFactory->CreateOperate();
    
            pCurOp->m_fNumberA = 1;
            pCurOp->m_fNumberB = 2;
    
            double fResoult = pCurOp->GetResoult();
    
            cout << fResoult;
    
            delete pCurOp;
            pCurOp = NULL;
    
            delete pCurFactory;
            pCurFactory = NULL;
        }
    }

\[color=red\]\[b\]  
抽象工厂好处是易于交换产品系列，一个应用只需要在初始化的时候出现一次，这使得改变一个应用的具体共产变得非常方便，它只需要改变具体工厂即可使用不同的产品配置。  
第二个好处是，它让具体的创建实例过程与客户端分离，客户端是通过他们的抽象接口操纵实例，产品的具体类名也被具体的工厂实现分离，不会出现在客户端代码中。  
\[/b\]\[/color\]  
  
  
\[img\]http://dl2.iteye.com/upload/attachment/0091/6123/34023d11-556f-3377-b883-6820347e8ed3.png\[/img\]

//AbstractFactoryPattern.h
    
    #ifndef ABSTRACY_FACTORY_PATTERN_H
    #define ABSTRACY_FACTORY_PATTERN_H
    
    #include <Windows.h>
    #include <string>
    using namespace std;
    
    namespace AbstractFactoryPattern
    {
       
        class User
        {
       
        public:
            User();
            ~User();
    
        public:
            int m_nID;
            string m_strName;
        };
    
        //
        class Department
        {
       
        public:
            Department();
            ~Department();
    
        public:
            int m_nID;
            string m_strName;
        };
    
        //
        class IUser
        {
       
        public:
            IUser();
            virtual ~IUser();
    
            virtual void Insert(User& cUser) = 0;
            virtual User* GetUser(int nUserID) = 0;
        };
    
    //Hidden these abstract classes
    //     class SqlServerUser : public IUser
    //     {
       
    //     public:
    //         SqlServerUser();
    //         virtual ~SqlServerUser();
    // 
    //         virtual void Insert(User& cUser);
    //         virtual User* GetUser(int nUserID);
    //     };
    // 
    //     class AccessUser : public IUser
    //     {
       
    //     public:
    //         AccessUser();
    //         virtual ~AccessUser();
    // 
    //         virtual void Insert(User& cUser);
    //         virtual User* GetUser(int nUserID);
    //     };
    
        //
        class IDepartment
        {
       
        public:
            IDepartment();
            virtual ~IDepartment();
    
            virtual void Insert(Department& cDepartment) = 0;
            virtual Department* GetDepartment(int nDepartmentID) = 0;
        };
    
    //Hidden these abstract classes
    //     class SqlServerDepartment : public IDepartment
    //     {
       
    //     public:
    //         SqlServerDepartment();
    //         virtual ~SqlServerDepartment();
    // 
    //         virtual void Insert(Department& cDepartment);
    //         virtual Department* GetDepartment(int nDepartmentID);
    //     };
    // 
    //     class AccessDepartment : public IDepartment
    //     {
       
    //     public:
    //         AccessDepartment();
    //         virtual ~AccessDepartment();
    // 
    //         virtual void Insert(Department& cDepartment);
    //         virtual Department* GetDepartment(int nDepartmentID);
    //     };
    
    
        //
        class IFactory
        {
       
        public:
            IFactory();
            ~IFactory();
    
            virtual IUser* CreateUser() = 0;
            virtual IDepartment* CreateDepartment() = 0;
        };
    
    //Hidden these abstract classes
    //     class SqlServerFactory : public IFactory
    //     {
       
    //     public:
    //         SqlServerFactory();
    //         virtual ~SqlServerFactory();
    // 
    //         virtual IUser* CreateUser();
    //         virtual IDepartment* CreateDepartment();
    //     };
    //     class AccessFactory: public IFactory
    //     {
       
    //     public:
    //         AccessFactory();
    //         virtual ~AccessFactory();
    // 
    //         virtual IUser* CreateUser();
    //         virtual IDepartment* CreateDepartment();
    //     };
    
    
        //
        void AbstractFactoryPattern_Test();
    
    }
    
    #endif

#include "AbstractFactoryPattern.h"
    #include <iostream>
    using namespace std;
    
    namespace AbstractFactoryPattern
    {
       
    
        //
        class SqlServerUser : public IUser
        {
       
        public:
            SqlServerUser();
            virtual ~SqlServerUser();
    
            virtual void Insert(User& cUser);
            virtual User* GetUser(int nUserID);
        };
    
        class AccessUser : public IUser
        {
       
        public:
            AccessUser();
            virtual ~AccessUser();
    
            virtual void Insert(User& cUser);
            virtual User* GetUser(int nUserID);
        };
    
        //
        class SqlServerDepartment : public IDepartment
        {
       
        public:
            SqlServerDepartment();
            virtual ~SqlServerDepartment();
    
            virtual void Insert(Department& cDepartment);
            virtual Department* GetDepartment(int nDepartmentID);
        };
    
        class AccessDepartment : public IDepartment
        {
       
        public:
            AccessDepartment();
            virtual ~AccessDepartment();
    
            virtual void Insert(Department& cDepartment);
            virtual Department* GetDepartment(int nDepartmentID);
        };
    
    
        //
        class SqlServerFactory : public IFactory
        {
       
        public:
            SqlServerFactory();
            virtual ~SqlServerFactory();
    
            virtual IUser* CreateUser();
            virtual IDepartment* CreateDepartment();
        };
        class AccessFactory: public IFactory
        {
       
        public:
            AccessFactory();
            virtual ~AccessFactory();
    
            virtual IUser* CreateUser();
            virtual IDepartment* CreateDepartment();
        };
    
    
        //
        User::User()
        {
       
        }
        User::~User()
        {
       
        }
    
        //
        Department::Department()
        {
       
        }
        Department::~Department()
        {
       
        }
    
        //
        IUser::IUser()
        {
       
        }
        IUser::~IUser()
        {
       
        }
    
        SqlServerUser::SqlServerUser()
        {
       
        }
        SqlServerUser::~SqlServerUser()
        {
       
        }
        void SqlServerUser::Insert(User& cUser)
        {
       
            cout << "Insert a record into TABLT User via SqlServer\n";
        }
        User* SqlServerUser::GetUser(int nUserID)
        {
       
            cout << "Fetch a record from TABLT User via SqlServer\n";
            return NULL;
        }
    
        AccessUser::AccessUser()
        {
       
        }
        AccessUser::~AccessUser()
        {
       
        }
        void AccessUser::Insert(User& cUser)
        {
       
            cout << "Insert a record into TABLT User via AccessUser\n";
        }
        User* AccessUser::GetUser(int nUserID)
        {
       
            cout << "Fetch a record from TABLT User via AccessUser\n";
            return NULL;
        }
    
        //
        IDepartment::IDepartment()
        {
       
        }
        IDepartment::~IDepartment()
        {
       
        }
        SqlServerDepartment::SqlServerDepartment()
        {
       
        }
        SqlServerDepartment::~SqlServerDepartment()
        {
       
        }
        void SqlServerDepartment::Insert(Department& cDepartment)
        {
       
            cout << "Insert a record into TABLT Department via SqlServer\n";
        }
        Department* SqlServerDepartment::GetDepartment(int nDepartmentID)
        {
       
            cout << "Fetch a record from TABLT Department via SqlServer\n";
            return NULL;
        }
    
        AccessDepartment::AccessDepartment()
        {
       
        }
        AccessDepartment::~AccessDepartment()
        {
       
        }
        void AccessDepartment::Insert(Department& cDepartment)
        {
       
            cout << "Insert a record into TABLT User via AccessUser\n";
        }
        Department* AccessDepartment::GetDepartment(int nDepartmentID)
        {
       
            cout << "Fetch a record from TABLT User via AccessUser\n";
            return NULL;
        }
    
    
        //
        IFactory::IFactory()
        {
       
        }
        IFactory::~IFactory()
        {
       
        }
    
        //
        SqlServerFactory::SqlServerFactory()
        {
       
        }
        SqlServerFactory::~SqlServerFactory()
        {
       
        }
        IUser* SqlServerFactory::CreateUser()
        {
       
            return new SqlServerUser();
        }
        IDepartment* SqlServerFactory::CreateDepartment()
        {
       
            return new SqlServerDepartment();
        }
    
        //
        AccessFactory::AccessFactory()
        {
       
        }
        AccessFactory::~AccessFactory()
        {
       
        }
        IUser* AccessFactory::CreateUser()
        {
       
           return new AccessUser();
        }
        IDepartment* AccessFactory::CreateDepartment()
        {
       
            return new AccessDepartment();
        }
    
        //
        void AbstractFactoryPattern_Test()
        {
       
            User cUser;
            Department cDepartment;
    
            IFactory* pFactory = new SqlServerFactory();
            IUser* pUser = pFactory->CreateUser();
            IDepartment* pDepartment = pFactory->CreateDepartment();
    
            pUser->Insert(cUser);
            pUser->GetUser(1);
    
            pDepartment->Insert(cDepartment);
            pDepartment->GetDepartment(1);
    
            delete pDepartment;
            pDepartment = NULL;
    
            delete pUser;
            pUser = NULL;
    
            delete pFactory;
            pFactory = NULL;
        }
    }

\[color=red\]\[b\]区别  
简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）  
工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）  
抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族） \[/b\]\[/color\]