StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p>If I understand this correctly, we want a factory function that can select which derived class to instantiate based on constructor inputs. This is the most generic solution that I could come up with so far. You specify mapping inputs to organize factory functions, and then you can specify constructor inputs upon factory invocation. I hate to say that the code explains more than I could in words, however I think the example implementations of <code>FactoryGen.h</code> in <code>Base.h</code> and <code>Derived.h</code> are clear enough with the help of comments. I can provide more details if necessary.</p> <p>FactoryGen.h</p> <pre><code>#pragma once #include <map> #include <tuple> #include <typeinfo> //C++11 typename aliasing, doesn't work in visual studio though... /* template<typename Base> using FactoryGen<Base> = FactoryGen<Base,void>; */ //Assign unique ids to all classes within this map. Better than typeid(class).hash_code() since there is no computation during run-time. size_t __CLASS_UID = 0; template<typename T> inline size_t __GET_CLASS_UID(){ static const size_t id = __CLASS_UID++; return id; } //These are the common code snippets from the factories and their specializations. template<typename Base> struct FactoryGenCommon{ typedef std::pair<void*,size_t> Factory; //A factory is a function pointer and its unique type identifier //Generates the function pointer type so that I don't have stupid looking typedefs everywhere template<typename... InArgs> struct FPInfo{ //stands for "Function Pointer Information" typedef Base* (*Type)(InArgs...); }; //Check to see if a Factory is not null and matches it's signature (helps make sure a factory actually takes the specified inputs) template<typename... InArgs> static bool isValid(const Factory& factory){ auto maker = factory.first; if(maker==nullptr) return false; //we have to check if the Factory will take those inArgs auto type = factory.second; auto intype = __GET_CLASS_UID<FPInfo<InArgs...>>(); if(intype != type) return false; return true; } }; //template inputs are the Base type for which the factory returns, and the Args... that will determine how the function pointers are indexed. template<typename Base, typename... Args> struct FactoryGen : FactoryGenCommon<Base>{ typedef std::tuple<Args...> Tuple; typedef std::map<Tuple,Factory> Map; //the Args... are keys to a map of function pointers inline static Map& get(){ static Map factoryMap; return factoryMap; } template<typename... InArgs> static void add(void* factory, const Args&... args){ Tuple selTuple = std::make_tuple(args...); //selTuple means Selecting Tuple. This Tuple is the key to the map that gives us a function pointer get()[selTuple] = Factory(factory,__GET_CLASS_UID<FPInfo<InArgs...>>()); } template<typename... InArgs> static Base* make(const Args&... args, const InArgs&... inArgs){ Factory factory = get()[std::make_tuple(args...)]; if(!isValid<InArgs...>(factory)) return nullptr; return ((FPInfo<InArgs...>::Type)factory.first) (inArgs...); } }; //Specialize for factories with no selection mapping template<typename Base> struct FactoryGen<Base,void> : FactoryGenCommon<Base>{ inline static Factory& get(){ static Factory factory; return factory; } template<typename... InArgs> static void add(void* factory){ get() = Factory(factory,__GET_CLASS_UID<FPInfo<InArgs...>>()); } template<typename... InArgs> static Base* make(const InArgs&... inArgs){ Factory factory = get(); if(!isValid<InArgs...>(factory)) return nullptr; return ((FPInfo<InArgs...>::Type)factory.first) (inArgs...); } }; //this calls the function "initialize()" function to register each class ONCE with the respective factory (even if a class tries to initialize multiple times) //this step can probably be circumvented, but I'm not totally sure how template <class T> class RegisterInit { int& count(void) { static int x = 0; return x; } //counts the number of callers per derived public: RegisterInit(void) { if ((count())++ == 0) { //only initialize on the first caller of that class T T::initialize(); } } }; </code></pre> <p>Base.h</p> <pre><code>#pragma once #include <map> #include <string> #include <iostream> #include "Procedure.h" #include "FactoryGen.h" class Base { public: static Base* makeBase(){ return new Base; } static void initialize(){ FactoryGen<Base,void>::add(Base::makeBase); } //we want this to be the default mapping, specify that it takes void inputs virtual void speak(){ std::cout << "Base" << std::endl; } }; RegisterInit<Base> __Base; //calls initialize for Base </code></pre> <p>Derived.h</p> <pre><code>#pragma once #include "Base.h" class Derived0 : public Base { private: std::string speakStr; public: Derived0(std::string sayThis){ speakStr=sayThis; } static Base* make(std::string sayThis){ return new Derived0(sayThis); } static void initialize(){ FactoryGen<Base,int>::add<std::string>(Derived0::make,0); } //we map to this subclass via int with 0, but specify that it takes a string input virtual void speak(){ std::cout << speakStr << std::endl; } }; RegisterInit<Derived0> __d0init; //calls initialize() for Derived0 class Derived1 : public Base { private: std::string speakStr; public: Derived1(std::string sayThis){ speakStr=sayThis; } static Base* make(std::string sayThat){ return new Derived0(sayThat); } static void initialize(){ FactoryGen<Base,int>::add<std::string>(Derived0::make,1); } //we map to this subclass via int with 1, but specify that it takes a string input virtual void speak(){ std::cout << speakStr << std::endl; } }; RegisterInit<Derived1> __d1init; //calls initialize() for Derived1 </code></pre> <p>Main.cpp</p> <pre><code>#include <windows.h> //for Sleep() #include "Base.h" #include "Derived.h" using namespace std; int main(){ Base* b = FactoryGen<Base,void>::make(); //no mapping, no inputs Base* d0 = FactoryGen<Base,int>::make<string>(0,"Derived0"); //int mapping, string input Base* d1 = FactoryGen<Base,int>::make<string>(1,"I am Derived1"); //int mapping, string input b->speak(); d0->speak(); d1->speak(); cout << "Size of Base: " << sizeof(Base) << endl; cout << "Size of Derived0: " << sizeof(Derived0) << endl; Sleep(3000); //Windows & Visual Studio, sry } </code></pre> <p>I think this is a pretty flexible/extensible factory library. While the code for it is not very intuitive, I think using it is fairly simple. Of course, my view is biased seeing as I'm the one that wrote it, so please let me know if it is the contrary.</p> <p><strong>EDIT :</strong> Cleaned up the FactoryGen.h file. This is probably my last update, however this has been a fun exercise.</p>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload