C++抽象工厂

桃扇骨 2022-09-17 03:13 19阅读 0赞

头文件：

#ifndef CABSTRACTFACTORY_H
    #define CABSTRACTFACTORY_H
    #include<iostream>
    #include<string>
    using namespace std;
    
    
    namespace CabstractFactory {
        
    
    class IHuman
    {
        
    public:
    
        IHuman(void)
        {
        
    
        }
    
        virtual ~IHuman(void)
        {
        
        }
    
        virtual void Laugh() = 0;
        virtual void Cry() = 0;
        virtual void Talk() = 0;
        virtual void Sex() = 0;
    };
    //抽象产品之一YellowHuman
    
    class CYellowHuman :
            public IHuman
    {
        
    public:
        CYellowHuman(void)
        {
        
        }
        ~CYellowHuman(void)
        {
        
        }
        void Laugh()
        {
        
            cout << "黄色人种会大笑，幸福呀！" << endl;
        }
        void Cry()
        {
        
            cout << "黄色人种会哭" << endl;
        }
        void Talk()
        {
        
            cout << "黄色人种会说话，一般说的都是双字节" << endl;
        }
        virtual void Sex() = 0;
    };
    
    //具体产品之一，继承自YellowHuman
    
    class CYellowFemaleHuman :
            public CYellowHuman
    {
        
    public:
        CYellowFemaleHuman(void)
        {
        
        }
        ~CYellowFemaleHuman(void)
        {
        
        }
        void Sex()
        {
        
            cout << "该黄种人的性别为女..." << endl;
        }
    };
    
    //具体产品，继承自YellowHuman
    class CYellowMaleHuman :
            public CYellowHuman
    {
        
    public:
        CYellowMaleHuman(void)
        {
        
        }
        ~CYellowMaleHuman(void)
        {
        
        }
        void Sex()
        {
        
            cout << "该黄种人的性别为男..." << endl;
        }
    };
    
    //抽象产品之二WhiteHuman
    
    class CWhiteHuman :
            public IHuman
    {
        
    public:
        CWhiteHuman(void)
        {
        
        }
        ~CWhiteHuman(void)
        {
        
        }
        void Laugh()
        {
        
            cout << "白色人种会大笑，侵略的笑声" << endl;
        }
        void Cry()
        {
        
            cout << "白色人种会哭" << endl;
        }
        void Talk()
        {
        
            cout << "白色人种会说话，一般都是单字节" << endl;
        }
        virtual void Sex() = 0;
    };
    //具体产品，继承自CWhiteHuman
    
    class CWhiteFemaleHuman :
            public CWhiteHuman
    {
        
    public:
        CWhiteFemaleHuman(void)
        {
        
        }
        ~CWhiteFemaleHuman(void)
        {
        
        }
        void Sex()
        {
        
            cout << "该白种人的性别为女..." << endl;
        }
    };
    //具体产品，继承自CWhiteHuman
    class CWhiteMaleHuman :
            public CWhiteHuman
    {
        
    public:
        CWhiteMaleHuman(void)
        {
        
        }
        ~CWhiteMaleHuman(void)
        {
        
        }
        void Sex()
        {
        
            cout << "该白种人的性别为男..." << endl;
        }
    };
    
    //抽象产品之三
    
    class CBlackHuman :
            public IHuman
    {
        
    public:
        CBlackHuman(void)
        {
        
        }
        ~CBlackHuman(void)
        {
        
        }
        void Laugh()
        {
        
            cout << "黑人会笑" << endl;
        }
        void Cry()
        {
        
            cout << "黑人会哭" << endl;
        }
        void Talk()
        {
        
            cout << "黑人可以说话，一般人听不懂" << endl;
        }
    
        virtual void Sex() = 0;
    };
    //具体产品，继承自CBlackHuman
    class CBlackFemaleHuman :
            public CBlackHuman
    {
        
    public:
        CBlackFemaleHuman(void)
        {
        
        }
        ~CBlackFemaleHuman(void)
        {
        
        }
        void Sex()
        {
        
            cout << "该黑种人的性别为女..." << endl;
        }
    };
    //具体产品，继承自CBlackHuman
    //BlackMaleHuman.h
    
    
    class CBlackMaleHuman :
            public CBlackHuman
    {
        
    public:
        CBlackMaleHuman(void)
        {
        
        }
        ~CBlackMaleHuman(void)
        {
        
        }
        void Sex()
        {
        
            cout << "该黑种人的性别为男..." << endl;
        }
    };
    
    
    //抽象工厂
    class IHumanFactory
    {
        
    public:
        IHumanFactory(void)
        {
        
        }
        virtual ~IHumanFactory(void)
        {
        
        }
        virtual IHuman * CreateYellowHuman() = 0;
        virtual IHuman * CreateWhiteHuman() = 0;
        virtual IHuman * CreateBlackHuman() = 0;
    };
    //抽象工厂基类（此类可有可无）
    template<class T>
    class CStandardHumanFactory :
            public IHumanFactory
    {
        
    public:
        CStandardHumanFactory(void)
        {
        
        }
        ~CStandardHumanFactory(void)
        {
        
        }
        IHuman * CreateHuman();
    };
    template<class T>
    IHuman * CStandardHumanFactory<T>::CreateHuman()
    {
        
        return new T;
    }
    
    //男人工厂
    
    template<class T>
    class CMaleHumanFactory :
            public CStandardHumanFactory<T>
    {
        
    public:
        CMaleHumanFactory(void);
        ~CMaleHumanFactory(void);
        IHuman * CreateYellowHuman();
        IHuman * CreateWhiteHuman();
        IHuman * CreateBlackHuman();
    };
    
    
    
    template<class T>
    CMaleHumanFactory<T>::CMaleHumanFactory(void)
    {
        
    }
    template<class T>
    CMaleHumanFactory<T>::~CMaleHumanFactory(void)
    {
        
    }
    template<class T>
    IHuman * CMaleHumanFactory<T>::CreateYellowHuman()
    {
        
        return this->CreateHuman();
    }
    template<class T>
    IHuman * CMaleHumanFactory<T>::CreateWhiteHuman()
    {
        
        return this->CreateHuman();
    }
    template<class T>
    IHuman * CMaleHumanFactory<T>::CreateBlackHuman()
    {
        
        return this->CreateHuman();
    }
    
    
    //女人工厂
    
    template<class T>
    class CFemaleHumanFactory :
            public CStandardHumanFactory<T>
    {
        
    public:
        CFemaleHumanFactory(void)
        {
        
        }
        ~CFemaleHumanFactory(void)
        {
        
        }
        IHuman * CreateYellowHuman()
        {
        
            return this->CreateHuman();
        }
        IHuman * CreateWhiteHuman()
        {
        
            return this->CreateHuman();
        }
        IHuman * CreateBlackHuman()
        {
        
            return this->CreateHuman();
        }
    };
    
    
    }
    
    
    #endif // CABSTRACTFACTORY_H

源文件：

#include "cabstractfactory.h"
    
    using namespace CabstractFactory;
    
    void CabstractfactoryTestt()
    {
        
        IHumanFactory *pFemaleHumanFactory = new CFemaleHumanFactory<CYellowFemaleHuman>();
        IHuman *pYellowFemaleHuman = pFemaleHumanFactory->CreateYellowHuman();
        pYellowFemaleHuman->Cry();
        pYellowFemaleHuman->Laugh();
        pYellowFemaleHuman->Talk();
        pYellowFemaleHuman->Sex();
        delete pYellowFemaleHuman;
        delete pFemaleHumanFactory;
    
        IHumanFactory *pMaleHumanFactory = new CMaleHumanFactory<CYellowMaleHuman>();
        IHuman *pYellowMaleHuman = pMaleHumanFactory->CreateYellowHuman();
        pYellowMaleHuman->Cry();
        pYellowMaleHuman->Laugh();
        pYellowMaleHuman->Talk();
        pYellowMaleHuman->Sex();
        delete pYellowMaleHuman;
        delete pMaleHumanFactory;
    
    }