Generic Derived Class Factory in C++

• Download factory.zip-1.49KB

Introduction

The goal of this article is to create a reusable class based on the Abstract Factory Pattern though, for some reason I can't remember, I chose to name it DerivedClassFactory. The design of this factory should allow us to register classes without changing anything within the factory itself. Another goal is to create a factory where the id used to generate the classes can be customized using C++ templates. The class also offers run time type safety with the help of templates and the dynamic_cast operator. We will be using the STL container map to keep our registration information, since STL comes with any decent C++ compiler and it is after all, a C++ standard.

Design

The design of our factory has the following straightforward specifications:

• Allow registration of classes
• Should have a data type for holding the information about registered classes and their ids
• Allow creation of registered classes through their ids

Based on this, we would have something like:

template<class _ID_, class _BASE_> class DerivedClassFactory { typedef _BASE_* (ClassFactoryFunc) (); private: std::map<_ID_, ClassFactoryFunc*> registry; // . . . };

The registry member variable holds our registration entry. This is a std::map object with template the class parameter _ID_ as key and a pointer to ClassFactoryFunc as value types respectively. We have defined ClassFactoryFunc as a function that returns a dynamically created instance of our base class, which is the class template parameter _BASE_.

At the heart of the factory is a generic function that actually instantiates the derived class we intend to register.

template<class _DERIVED_> static _BASE_* derivedClassFactoryFunc() { _DERIVED_* t = new _DERIVED_; _BASE_* c = dynamic_cast<_BASE_*>(t); // For type safety if (!c) delete t; return c; }

This is a static function that will provide us with a ClassFactoryFunc pointer that we can store in our registry. Type safey is acheived by dynamic_casting the derived type pointer to our base class.

We now add the method to register a class:

void registerClass(_ID_ id, ClassFactoryFunc* func) { registry.insert(std::pair<_ID_, ClassFactoryFunc*>(id, func)); }

To create or instantiate our registered classes we then use the following method:

_BASE_* create(_ID_ s) { _BASE_* obj = 0; typename std::map<_ID_, ClassFactoryFunc*>::iterator it = registry.find(s); if (it != registry.end()) { ClassFactoryFunc* pFunc = it->second; obj = pFunc(); } return obj; }

which is just a matter of searching for the id we want in the registry and executing the function pointer that we stored earlier.

Using the Factory

To use our factory we need to instantiate it with the template parameters _ID_  and _BASE_ which is our id and base class types respectively:

DerivedClassFactory<std::string, Base> fac;

To register classes we just use the registerClass function:

fac.registerClass("Derived1", DerivedClassFactory<std::string, Base>::derivedClassFactoryFunc<Derived>);

Or we could use the a macro that does just what the above code does:

FACTORY_REGISTER_CLASS(fac, std::string, Base, "Derived2", Derived2);

To create an object:

Base* obj = fac.create("Derived1");

Points of Interest

The extra delete in derivedClassFactoryFunc is a pain if you are dealing with large classes. But, it is necessary and should not happen if you write your code with forethought and care.

Conclusion

The Abstract Factory pattern is a common pattern in software engineering. Harnessing the power of templates in C++ allowed us to create a factory that is simple, type-safe, reusable and allows us to register classes without changing the factory class code itself.

License

This article, along with any associated source code and files, is licensed under The Intelliproject Open License (IPOL)

About the author