Template factory of objects (once again, and in fifteen lines)

Hello!

I am very new to C ++, I generally program solely for my own pleasure (and sometimes for several exotic platforms), I haven’t read theoretical books, I actively use Google, Stack Overflow and intuition in the process of writing, and also adhere to the opinion that it’s impossible to know C ++.
')
I hope this removes some questions and prevents surprised looks. :)

Nevertheless, I once wrote (on the pros and with Qt 'ohm) in my spare time in my free time, and then I thought that it would be nice to screw in some mechanism, which some people have turned out to be called a factory of objects. And, as I understand it, there is a more general design pattern , called an abstract object factory , the essence of which I did not catch, as well as a simpler abstraction, the essence of which is that the object knows about a number of class-identifier pairs, and then it can create instances of classes by their identifier (in the simplest case, this identifier is a string, but it may be convenient to use, for example, an enumeration). When I more or less understood what I wanted (that is, the last one), I climbed to look for ready-made, beautiful solutions that would suit me, but, having raped almost all Google, surprisingly, I did not find one.

As a result, having spent an inadmissible amount of time on such nonsense, I gathered from a heap of places (reaching the rest of Google) my unique and, I think, yet elegant small (really small ... I even doubt the need for a whole post ...) Bicycle, having managed to figure out a lot with what, including with template classes, template functions, specialization and even variadic templates and functions from C ++ 11 .

Make a reservation what exactly I want. Firstly, of course, I read the article of the hatorsuber man rtorsten. We put objects on the flow, the pattern of the factory of objects , but the meaning of everything and everything doesn’t reach me so far, the implementation seems a bit overloaded, and I’m not I see. You can say this post is an attempt to do roughly the same thing, but better. Well, and secondly, what I wanted and what I achieved (it must have coincided :)): suppose we have the base class Base and two immediate heirs from it: Derived1 and Derived2 , the instances of which we want to create by the factory.

The above is covered in that article, but I also want

• create instances of classes with various constructor arguments;
• have one single factory implementation for any base class and any number and types of constructor arguments;
• do not need to modify classes in order to add them to the factory.

That is something like this:

 #include <iostream> #include <string> #include "factory.h" using namespace std; class Animal{ public: Animal(bool isAlive,string name) : isAlive(isAlive),name(name){}; bool isAlive; string name; virtual string voice() const=0; }; class Dog : public Animal{ public: using Animal::Animal; string voice() const{ return this->isAlive? "Woof! I'm "+this->name+"\n": ""; } }; class Cat : public Animal{ public: using Animal::Animal; string voice() const{ return this->isAlive? "Meow, I'm "+this->name+"\n": ""; } }; int main(void){ GenericObjectFactory<string,Animal,bool,string> animalFactory; animalFactory.add<Dog>("man's friend"); animalFactory.add<Cat>("^_^"); Animal *dog1=animalFactory.get("man's friend")(true,"charlie"); Animal *dog2=animalFactory.get("man's friend")(false,"fido"); Animal *cat =animalFactory.get("^_^")(true,"begemoth"); cout << dog1->voice() << dog2->voice() << cat ->voice(); return 0; } 

Thus, the animalFactory factory is first created from the animalFactory template class, the first required parameter of which is the key type (in this example, a string, but it can also be handy to use something else, such as an integer value or an enumeration) of a map type, where the values ​​are the classes that will then need to be added to the factory so that it can create them; as the second mandatory parameter - the base class of these classes (and they must be inherited from one class); the remaining two parameters, which can be any number (including zero), are the types of the arguments of the class constructor created by the factory, in turn.

Then you can add classes to the factory by calling the template member function add , specifying, as the first and only parameter, the class that the factory needs to register, and the first and only argument is the identifier of this class, in our case the string (defined the first parameter of the template class).

Then the fun begins. The member function get takes the id string as the first and only argument, and returns the so-called instantiator of the class found by this id. Instantiator is such a function that will take a set of arguments (in the number and types specified in the factory specialization) and create an instance of the desired class, passing them to the constructor. A kind of proxy, which is needed later I will explain why. It is very similar to the fact that the constructor itself was returned. :) It will return an instantiator with a pointer to the created object, but this pointer is of a type not of the inherited, but of the base class. With a great desire, then you can dynamic_cast 'thread.

By the way, nothing prevents to save the given instantiator somewhere:

 auto catInstantiator=animalFactory.get("^_^"); 

, and already to create objects later, when it will be necessary:

 Animal *cat=catInstantiator(true,"delayed cat"); Animal *cat=catInstantiator(false,"dead delayed cat"); 

:)
But ok, in the end it was obvious. It’s also obvious that I’m writing this note not to the young plusists, but to the newcomers, who for some reason wanted a factory for themselves. :)

---

Let's look at the implementation of the factory. I deliberately cut out everything without which it would not work, including any checks for the presence or absence of a class in a factory when creating or registering and similar logic and all other amenities (or rather, I was too lazy to transfer it from Qt to STL), no good it is not difficult to finish it. But in general, I still think that the example code should be as simple and obvious as possible, without these undoubtedly inevitable diabolical details: it's easier to understand, and this is exactly what is needed now.

1. #include <map>
3. template < class ID, class Base, class ... Args > class GenericObjectFactory {
4. private :
5. typedef Base * ( * fInstantiator ) ( Args ... ) ;
6. template < class Derived > static Base * instantiator ( Args ... args ) {
7. return new Derived ( args ... ) ;
8. }
9. std :: map < ID, fInstantiator > classes ;
11. public :
12. GenericObjectFactory ( ) { }
13. template < class Derived > void add ( ID id ) {
14. classes [ id ] = & instantiator < Derived > ;
15. }
16. fInstantiator get ( id id ) {
17. return classes [ id ] ;
18. }
20. } ;

And that's it! Isn't it elengant? It seems to me that I exceeded the rtorsten solution proposed in his article at least three times.

So what happens here:

• First line: all you need is a map container. In this case, take STL-evsky. But the QMap also fits without problems.
• Third line: template definition. About magic three points (variadic templates) can be read in Google , on Wikipedia , or even on Habré (Respect to the FlexFerrum habrayuzer ).
• Fifth : the definition of the fInstantiator type. It is a pointer to a function that returns a pointer to an object of type Base (a template parameter) and accepts arguments of types Args ... (also a template parameter, but there can be an arbitrary number, see variadic templates ) returned by the member function get (line 16 ).
• Sixth : just such a function, the same instantiator , about which we spoke, with the template. This is necessary so that this function can be specialized with the Derived class added to the factory , which makes the template member function void add<class Derived> , and then take it to the specialized function address (which only creates objects of this class) and place to the container std::map classes as a value, where the key is an argument of the void add<class Derived> function void add<class Derived> type of ID (the first parameter of the factory template). instantiator declared static for simplicity, but if you really need, you can use the so-called member function pointers .
• On the seventh line, the creation of an object actually takes place, and the constructor of this object is passed the arguments in the number and types specified in the factory specialization, and their instantiator , in fact, accepts their arguments. Of course, in the same number and types, and of course, this is all known at compile time, and if none of the constructors of any of the classes added to the factory accepts arguments of these types, the compiler throws an error.
• The ninth line: the container in which the factory stores the classes added to it during execution. The core of the factory. The key, as we have said, is of the type specified by the first parameter of the template - everything is simple. But the value is just that magic pointer to the template function. After specialization (by any class inherited from Base ), the function has the same signature, that is, always (with any parameter of the template) takes the known and the same number and type of arguments, and always returns the value of the same known type - a pointer to an object of type Base . That is, the original problem is solved! :)
• The fourteenth line: the add function adds to std::map classes pair of id types ID (the first parameter of the class template) and the address of the static instantiator member function that was just specialized. Already spoken.
• Seventeenth (well, I wanted to practice writing numerals) line: the get function returns a pointer to the instantiator desired class. Please note that at the moment an object is not created, the user then does it himself using the issued instantiator . This is exactly what I wanted to achieve.

Did I already say that I am new to C ++ ? :) So, it is quite possible that I lied in some places (or maybe only in some places I did not lie ...), but I can definitely say that it all works.

Just take the last listing, insert it into the first one instead of #include "factory.h" and check the result in your favorite compiler, without forgetting to include support for the C ++ 11 standard.

PS In general, initially I wanted to leave my version of the factory with a comment on the first article, but for some reason I wrote a post ... in any case, I will be extremely happy to discuss, errors in drugs and ... do not hit hard. :)

PPS Oh! I just wanted to send it, but I remembered that there is still Ideone ! Filled example there: you can admire . :)