[创建型模式] AbstractFactory

骑猪看日落 2021-12-10 13:47 109阅读 0赞

AbstractFactory.h

//
    //  AbstractFactory.h
    //  AbstractFactory
    //
    //  Created by Cheney Shen on 11-2-20.
    //  Copyright 2011年 __MyCompanyName__. All rights reserved.
    //
    
    #ifndef _ABSTARCTFACTORY_H_
    #define _ABSTRACTFACOTRY_H_
    
    class AbstractProductA;
    class AbstractProductB;
    
    class AbstractFactory
    {
        public:
        virtual ~AbstractFactory();
        virtual AbstractProductA* CreateProductA()=0;
        virtual AbstractProductB* CreateProductB()=0;
    
        protected:
        AbstractFactory();
        
        private:
        
    };
    
    class ConcreteFactory1: public AbstractFactory
    {
        public:
        ConcreteFactory1();
        ~ConcreteFactory1();
        AbstractProductA* CreateProductA();
        AbstractProductB* CreateProductB();
        
        protected:
        
        private:
        
    };
    
    class ConcreteFactory2: public AbstractFactory
    {
        public:
        ConcreteFactory2();
        ~ConcreteFactory2();
        AbstractProductA* CreateProductA();
        AbstractProductB* CreateProductB();
        
        protected:
        
        private:
        
    };
    
    #endif  //~_ABSTRACTFACTORY_H_

AbstractFactory.cpp

//
    //  AbstractFactory.cpp
    //  AbstractFactory
    //
    //  Created by Cheney Shen on 11-2-20.
    //  Copyright 2011年 __MyCompanyName__. All rights reserved.
    //
    
    #include "AbstractFactory.h"
    #include "Product.h"
    #include <iostream>
    using namespace std;
    
    AbstractFactory::AbstractFactory()
    {
        
    }
    
    AbstractFactory::~AbstractFactory()
    {
        
    }
    
    ConcreteFactory1::ConcreteFactory1()
    {
        
    }
    
    ConcreteFactory1::~ConcreteFactory1()
    {
        
    }
    
    AbstractProductA* ConcreteFactory1::CreateProductA()
    {
        return new ProductA1();
    }
    
    AbstractProductB* ConcreteFactory1::CreateProductB()
    {
        return new ProductB1();
    }
    
    ConcreteFactory2::ConcreteFactory2()
    {
        
    }
    
    ConcreteFactory2::~ConcreteFactory2()
    {
        
    }
    
    AbstractProductA* ConcreteFactory2::CreateProductA()
    {
        return new ProductA2();
    }
    
    AbstractProductB* ConcreteFactory2::CreateProductB()
    {
        return new ProductB2();
    }

Product.h

//
    //  Product.h
    //  AbstractFactory
    //
    //  Created by Cheney Shen on 11-2-20.
    //  Copyright 2011年 __MyCompanyName__. All rights reserved.
    //
    
    #ifndef _PRODUCT_H_
    #define _PRODUCT_H_
    
    class AbstractProductA
    {
        public:
        virtual ~AbstractProductA();
        
        protected:
        AbstractProductA();
        
        private:
        
    };
    
    class AbstractProductB
    {
        public:
        virtual ~AbstractProductB();
        
        protected:
        AbstractProductB();
        
        private:
        
    };
    
    class ProductA1: public AbstractProductA
    {
        public:
        ProductA1();
        ~ProductA1();
        
        protected:
        
        private:
    };
    
    class ProductA2: public AbstractProductA
    {
        public:
        ProductA2();
        ~ProductA2();
        
        protected:
        
        private:
        
    };
    
    class ProductB1: public AbstractProductB
    {
        public:
        ProductB1();
        ~ProductB1();
        
        protected:
        
        private:
        
    };
    
    class ProductB2: public AbstractProductB
    {
        public:
        ProductB2();
        ~ProductB2();
        
        protected:
        
        private:
        
    };
    
    #endif  //~_PRODUCT_H_

Product.cpp

//
    //  Product.cpp
    //  AbstractFactory
    //
    //  Created by Cheney Shen on 11-2-20.
    //  Copyright 2011年 __MyCompanyName__. All rights reserved.
    //
    
    #include "Product.h"
    #include <iostream>
    using namespace std;
    
    AbstractProductA::AbstractProductA()
    {
        
    }
    
    AbstractProductA::~AbstractProductA()
    {
        
    }
    
    AbstractProductB::AbstractProductB()
    {
        
    }
    
    AbstractProductB::~AbstractProductB()
    {
        
    }
    
    ProductA1::ProductA1()
    {
        cout<<"ProductA1..."<<endl;
    }
    
    ProductA1::~ProductA1()
    {
        
    }
    
    ProductA2::ProductA2()
    {
        cout<<"ProductA2..."<<endl;
    }
    
    ProductA2::~ProductA2()
    {
        
    }
    
    ProductB1::ProductB1()
    {
        cout<<"ProductB1..."<<endl;
    }
    
    ProductB1::~ProductB1()
    {
        
    }
    
    ProductB2::ProductB2()
    {
        cout<<"ProductB2..."<<endl;
    }
    
    ProductB2::~ProductB2()
    {
        
    }

main.cpp

//
    //  main.cpp
    //  AbstractFactory
    //
    //  Created by Cheney Shen on 11-2-20.
    //  Copyright 2011年 __MyCompanyName__. All rights reserved.
    //
    
    #include "AbstractFactory.h"
    
    #include <iostream>
    using namespace std;
    
    int main (int argc, const char * argv[]) {
    
        AbstractFactory* cf1 = new ConcreteFactory1();
        
        cf1->CreateProductA();
        cf1->CreateProductB();
        
        AbstractFactory* cf2 = new ConcreteFactory2();
        
        cf2->CreateProductA();
        cf2->CreateProductB();
        
        return 0;
    }

转载于:https://www.cnblogs.com/shenfei2031/archive/2011/03/10/1979303.html