With one project, they had assembled a factory system with all sorts of Macros. Macros were already a bit passé a while ago, but with IDEs and their various tools, I have even less desire to see them in our code. While researching some alternatives, I came across this post. It's a little dated so I adapted it some for the modern era. What follows is built around C++14 and some modifications may be needed to adapt to 11, and improvements still exist going up to C++17.
Let's start with the big picture and then break it down some.
Factory
#include <algorithm>
#include <functional>
#include <functional>
#include <map>
#include <memory>
template <class Base, typename ClassIDKey=std::string>
class GenericFactory
{
using BaseCreateFn = std::function<std::unique_ptr<Base>()>;
using FnRegistry = std::map<ClassIDKey, BaseCreateFn>;
public:
static GenericFactory& instance(){
static GenericFactory factory;
return factory;
}
void RegCreateFn(const ClassIDKey& key, const BaseCreateFn& createFunction){
auto regIt = std::find_if(registry.begin(), registry.end(),
[key](const auto ®istryEntry) {
return key == registryEntry.first;
});
if (registry.end() == regIt) {
registry.emplace(key, createFunction);
} else {
registry.at(key) = createFunction;
}
auto regIt = std::find_if(registry.begin(), registry.end(),
[key](const auto ®istryEntry) {
return key == registryEntry.first;
});
if (registry.end() == regIt) {
registry.emplace(key, createFunction);
} else {
registry.at(key) = createFunction;
}
registry.emplace(key, createFunction);
}
std::unique_ptr<Base> Create(const ClassIDKey& key) const{
auto registryIt = registry.find(key);
if(registry.cend() != registryIt){
return registryIt->second();
}
return nullptr;
}
private:
GenericFactory(){}
FnRegistry registry;
};
template <typename Base,
typename Derived,
typename ClassIDKey=std::string,
typename = std::enable_if_t<std::is_base_of<Base, Derived>::value>
typename Derived,
typename ClassIDKey=std::string,
typename = std::enable_if_t<std::is_base_of<Base, Derived>::value>
class RegisterInFactory
{
public:
static std::unique_ptr<Base> CreateInstance()
{
// if c++ 11, would just use the traditional constructor
// if c++ 11, would just use the traditional constructor
return std::make_unique<Base>();
}
RegisterInFactory(const ClassIDKey &id)
{
GenericFactory<Base>::instance().RegCreateFn(id, CreateInstance);
}
};
Factory structure
The core of the Factory is a map of some key to some function that creates a smart pointer to the base class out of some new derived class. We've set up some aliases for readability, but they aren't strictly necessary. Compared to the post on Dobbs' you can see I've updated from the atrocious old function pointers to the new functional objects. We don't, as far as I'm aware, gain tons of advantage technically here, but I might speculate there are some out there. Mostly I did it because the function objects are just so much easier to read.
Skipping down to GenericFactory::Create, this would be the function that actually gets called in a program. A key is passed in, searches through the registry of pseudo-constructors for the right constructor and then returns the result of the call to it.
Skipping down to GenericFactory::Create, this would be the function that actually gets called in a program. A key is passed in, searches through the registry of pseudo-constructors for the right constructor and then returns the result of the call to it.
Finally, we want our factory to be a singleton. So we require the use of the 'instance' function to get a hold of the factory, and hide our constructor in private.
Factory Registration
The GenericFactory could stand on its own if we wanted, and in some of the advanced techniques we may take advantage of that fact. But, just like the post in Dobbs', we can easily simplify how this factory works by adding this helper class "RegisterInFactory."
The actual construction doesn't particularly need us to go out and define some functor that returns the appropriately wrapped construction of the Derived class, so a static member function will still fulfill the signature for our create function. (the 'CreateInstance Function). As for the class itself, construction will register the function to our factory. We'll see how that happens in...
Using the factory
Base Class
It's not just enough to say what the factory looks like, it helps to actually see it in use. We'll start with some trivial base class
(BaseClass.h)
(BaseClass.h)
#include "GenericFactory.h"
class BaseClass
{
public:
virtual ~BaseClass();
virtual void print() = 0;
};
using BaseFactory = GenericFactory<BaseClass>;
Now, the base class could be an actual class and not just a pure virtual, but I rather like this pattern as a means to make interfaces a bit more useable. If, perhaps you'd like to have default implementations of the functions, but still disallow construction of the Base class, you can do the usual and define the constructor as a protected function.
We don't technically need to do pretty much anything here, technically. However, I find that having the factory included here is simpler than including it through all the subclasses. Especially since we're hoping that users of this will use our factory to construct them rather than doing so directly. Including it here also allows us to throw in an alias to this Generic Factory as opposed to some other one. (The point of defining it Generically is that you could use that one factory template to produce many kinds of factories for many different base classes).
Nothing at all needs to be done in the source file (.cpp), but if your Base class is a useful one, you may want to have your factory produce a base pointer to the base class. In which case you'll follow the same pattern as the...
Nothing at all needs to be done in the source file (.cpp), but if your Base class is a useful one, you may want to have your factory produce a base pointer to the base class. In which case you'll follow the same pattern as the...
Derived Class
While BaseClass had its action in the header, Derived only needs a modification to the source file
(Derived_1.cpp)
(Derived_1.cpp)
#include "Derived_1.h"
#include <iostream>
namespace {
RegisterInFactory<BaseClass, Derived_1> registerMe{"Derived 1"};
} // anonymous namespace
Derived_1::Derived_1() : BaseClass()
{
}
void Derived_1::print()
{
std::cout << "Printing from Derived class 1" << std::endl;
}
Here all we need to note is the use of the 'RegisterInFactory' class. The template signature following RegisterInFactory tells us which type to register to which factory. While we never use the global object created by it, the act of making that object registers the class to the factory. You could do this with static objects, but I like anonymous namespaces here, especially since we're explicitly not using this object, the object created is constrained to this source file.
User of factory
(UserOfBases.cpp)
#include "UserOfBases.h"
#include "BaseClass.h"
void UserOfBases::printFromDerived(const std::string& derivedType)
{
std::unique_ptr<BaseClass> object =BaseFactory::instance().Create(derivedType);
object->print();
}
Here we see some example of how all of this comes together. It's so simple I can't really think of what else to say about it. Certainly outside of a little toy program there would be a lot more going on with our created object, but this illustrates the use nicely.
Example code here
Coming up next: What do you do when your class needs to be initialized as part of the constructor? Generic Factories with Initializers!
