Click here to Skip to main content
65,938 articles
CodeProject is changing. Read more.
Articles / Languages / C++

Factory class with Open Closed Principle

5.00/5 (2 votes)
30 Apr 2013CPOL 16.6K   106  
Simple Factory class with Open Closed principle.

Introduction

This is to demonstrate a simple template based factory class which can be used as a generic class satisfying the concept of Open Closed Principle (OCP). There could be many enhancements but to get the idea straight, I am keeping it simple. Nothing much to write, the code speaks itself.

Using the code

The BaseFactory class is the main class to demonstrate the above idea. A specialized type of factory instance for some Product type hierarchy can be created as below:

C++
BaseFactory<Product> productFactory;

To register a new Product type:

C++
productFactory.RegisterType<P1>("P1");

To create instance of a Product type:

C++
Product* product = productFactory.CreateInstance("P1");

Below is the complete implementation for the BaseFactory class:

C++
// Base template Factory class

template<class T>
class BaseFactory
{
public:
    T *CreateInstance(std::string typeName)
    {
        TypeMap::iterator it = mTypeMap.find(typeName); 

        if ( it != mTypeMap.end())
        {
            return it->second();
        }
 
        return NULL;
    } 
 
    template<class DerivedT> 
   
    void RegisterType(std::string derivedTypeName)
    {
        this->mTypeMap[derivedTypeName] = &BaseFactory<T>::CreateT<DerivedT>;
    }

private:
    typedef std::map<std::string, T *(*)()> TypeMap;
    TypeMap mTypeMap;
    template<class DerivedT>
    static T* CreateT() { return new DerivedT; }
};

History

  • 30 Apr 2013: Initial revision.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)