Gibt es eine Möglichkeit, Objekte aus einer Zeichenfolge mit ihrem Klassennamen zu instanziieren?

NÖ, es gibt keine, es sei denn, Sie tun das mapping selbst. C++ hat keinen Mechanismus, um Objekte zu erstellen, deren Typen werden zur Laufzeit ermittelt. Sie können mit einer Karte zu tun, die Zuordnung jedoch selbst:

template<typename T> Base * createInstance() { return new T; }

typedef std::map<std::string, Base*(*)()> map_type;

map_type map;
map["DerivedA"] = &createInstance<DerivedA>;
map["DerivedB"] = &createInstance<DerivedB>;

Dann kann man

return map[some_string]();

Immer eine neue Instanz. Eine weitere Idee ist, dass die Typen registrieren Sie sich:

//in base.hpp:
template<typename T> Base * createT() { return new T; }

struct BaseFactory {
    typedef std::map<std::string, Base*(*)()> map_type;

    static Base * createInstance(std::string const& s) {
        map_type::iterator it = getMap()->find(s);
        if(it == getMap()->end())
            return 0;
        return it->second();
    }

protected:
    static map_type * getMap() {
        //never delete'ed. (exist until program termination)
        //because we can't guarantee correct destruction order 
        if(!map) { map = new map_type; } 
        return map; 
    }

private:
    static map_type * map;
};

template<typename T>
struct DerivedRegister : BaseFactory { 
    DerivedRegister(std::string const& s) { 
        getMap()->insert(std::make_pair(s, &createT<T>));
    }
};

//in derivedb.hpp
class DerivedB {
    ...;
private:
    static DerivedRegister<DerivedB> reg;
};

//in derivedb.cpp:
DerivedRegister<DerivedB> DerivedB::reg("DerivedB");

Könnten Sie sich entscheiden, erstellen Sie ein makro für die Registrierung

#define REGISTER_DEC_TYPE(NAME) \
    static DerivedRegister<NAME> reg

#define REGISTER_DEF_TYPE(NAME) \
    DerivedRegister<NAME> NAME::reg(#NAME)

Ich bin sicher, es gibt bessere Namen für die zwei, obwohl. Eine andere Sache, die Sinn macht zu nutzen, hier ist shared_ptr.

Wenn Sie eine Reihe von nicht verwandten Arten, die keine gemeinsame Basis-Klasse haben, können Sie die Funktion Zeiger als return-type der boost::variant<A, B, C, D, ...> statt. Wie, wenn Sie eine Klasse Foo, Bar und Baz, sieht es wie folgt aus:

typedef boost::variant<Foo, Bar, Baz> variant_type;
template<typename T> variant_type createInstance() { 
    return variant_type(T()); 
}

typedef std::map<std::string, variant_type (*)()> map_type;

Einen boost::variant ist wie eine union. Er weiß, welcher Typ ist in ihm gespeichert sind, indem Sie suchen, was Objekt wurde initialisiert oder zugewiesen. Ein Blick in die Dokumentation hier. Schließlich ist die Verwendung des raw-Funktion-Zeiger ist auch ein bisschen ältlich. Moderne C++ - code sollte abgekoppelt von bestimmten Funktionen /Arten. Möchten Sie vielleicht einen Blick in Boost.Funktion suchen nach einem besseren Weg. Es würde dann so Aussehen (der Karte):

typedef std::map<std::string, boost::function<variant_type()> > map_type;

std::function verfügbar sein wird in der nächsten version von C++ zu, einschließlich std::shared_ptr.

InformationsquelleAutor der Antwort Johannes Schaub - litb

Die kurze Antwort ist, können Sie nicht. Siehe diesen Fragen warum:

1. Warum hat C++ keine Reflexion?
2. Wie kann ich Reflexion an einer C++ - Anwendung?

InformationsquelleAutor der Antwort Michael Kristofik

boost::funktional hat ein Werk die Vorlage, die ist Recht flexibel: http://www.boost.org/doc/libs/1_54_0/libs/functional/factory/doc/html/index.html

Meine Vorliebe allerdings ist das generieren von wrapper-Klassen, die das verbergen der mapping-und Objekt-Erstellung Mechanismus. Die häufigste Szenario, das ich begegnen, ist die Notwendigkeit für die Kartierung von verschiedenen abgeleiteten Klassen einige Basis-Klasse zu Tasten, wo die abgeleiteten Klassen haben alle einen gemeinsamen Konstruktor-Signatur zur Verfügung. Hier ist die Lösung, die ich mir ausgedacht habe, so weit.

#ifndef GENERIC_FACTORY_HPP_INCLUDED

//BOOST_PP_IS_ITERATING is defined when we are iterating over this header file.
#ifndef BOOST_PP_IS_ITERATING

    //Included headers.
    #include <unordered_map>
    #include <functional>
    #include <boost/preprocessor/iteration/iterate.hpp>
    #include <boost/preprocessor/repetition.hpp>

    //The GENERIC_FACTORY_MAX_ARITY directive controls the number of factory classes which will be generated.
    #ifndef GENERIC_FACTORY_MAX_ARITY
        #define GENERIC_FACTORY_MAX_ARITY 10
    #endif

    //This macro magic generates GENERIC_FACTORY_MAX_ARITY + 1 versions of the GenericFactory class.
    //Each class generated will have a suffix of the number of parameters taken by the derived type constructors.
    #define BOOST_PP_FILENAME_1 "GenericFactory.hpp"
    #define BOOST_PP_ITERATION_LIMITS (0,GENERIC_FACTORY_MAX_ARITY)
    #include BOOST_PP_ITERATE()

    #define GENERIC_FACTORY_HPP_INCLUDED

#else

    #define N BOOST_PP_ITERATION() //This is the Nth iteration of the header file.
    #define GENERIC_FACTORY_APPEND_PLACEHOLDER(z, current, last) BOOST_PP_COMMA() BOOST_PP_CAT(std::placeholders::_, BOOST_PP_ADD(current, 1))

    //This is the class which we are generating multiple times
    template <class KeyType, class BasePointerType BOOST_PP_ENUM_TRAILING_PARAMS(N, typename T)>
    class BOOST_PP_CAT(GenericFactory_, N)
    {
        public:
            typedef BasePointerType result_type;

        public:
            virtual ~BOOST_PP_CAT(GenericFactory_, N)() {}

            //Registers a derived type against a particular key.
            template <class DerivedType>
            void Register(const KeyType& key)
            {
                m_creatorMap[key] = std::bind(&BOOST_PP_CAT(GenericFactory_, N)::CreateImpl<DerivedType>, this BOOST_PP_REPEAT(N, GENERIC_FACTORY_APPEND_PLACEHOLDER, N));
            }

            //Deregisters an existing registration.
            bool Deregister(const KeyType& key)
            {
                return (m_creatorMap.erase(key) == 1);
            }

            //Returns true if the key is registered in this factory, false otherwise.
            bool IsCreatable(const KeyType& key) const
            {
                return (m_creatorMap.count(key) != 0);
            }

            //Creates the derived type associated with key. Throws std::out_of_range if key not found.
            BasePointerType Create(const KeyType& key BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N,const T,& a)) const
            {
                return m_creatorMap.at(key)(BOOST_PP_ENUM_PARAMS(N,a));
            }

        private:
            //This method performs the creation of the derived type object on the heap.
            template <class DerivedType>
            BasePointerType CreateImpl(BOOST_PP_ENUM_BINARY_PARAMS(N,const T,& a))
            {
                BasePointerType pNewObject(new DerivedType(BOOST_PP_ENUM_PARAMS(N,a)));
                return pNewObject;
            }

        private:
            typedef std::function<BasePointerType (BOOST_PP_ENUM_BINARY_PARAMS(N,const T,& BOOST_PP_INTERCEPT))> CreatorFuncType;
            typedef std::unordered_map<KeyType, CreatorFuncType> CreatorMapType;
            CreatorMapType m_creatorMap;
    };

    #undef N
    #undef GENERIC_FACTORY_APPEND_PLACEHOLDER

#endif //defined(BOOST_PP_IS_ITERATING)
#endif //include guard

Ich bin generell gegen schwere makro verwenden, aber ich habe eine Ausnahme hier. Der obige code erzeugt GENERIC_FACTORY_MAX_ARITY + 1 Versionen einer Klasse namens GenericFactory_N, für jedes N zwischen 0 und GENERIC_FACTORY_MAX_ARITY inclusive.

Verwendung der generierten Klassen-templates ist sehr einfach. Angenommen, Sie möchten eine factory zum erstellen von BaseClass abgeleitet Objekte mit einem string-mapping. Jede der abgeleiteten Objekte 3 Ganzzahlen als Konstruktor-Parameter.

#include "GenericFactory.hpp"

typedef GenericFactory_3<std::string, std::shared_ptr<BaseClass>, int, int int> factory_type;

factory_type factory;
factory.Register<DerivedClass1>("DerivedType1");
factory.Register<DerivedClass2>("DerivedType2");
factory.Register<DerivedClass3>("DerivedType3");

factory_type::result_type someNewObject1 = factory.Create("DerivedType2", 1, 2, 3);
factory_type::result_type someNewObject2 = factory.Create("DerivedType1", 4, 5, 6);

Den GenericFactory_N Klasse Destruktor virtuell ist, dass die folgenden.

class SomeBaseFactory : public GenericFactory_2<int, BaseType*, std::string, bool>
{
    public:
        SomeBaseFactory() : GenericFactory_2()
        {
            Register<SomeDerived1>(1);
            Register<SomeDerived2>(2);
        }
}; 

SomeBaseFactory factory;
SomeBaseFactory::result_type someObject = factory.Create(1, "Hi", true);
delete someObject;

Beachten Sie, dass diese Zeile die generische Fabrik-generator makro -

#define BOOST_PP_FILENAME_1 "GenericFactory.hpp"

Übernimmt die generische Fabrik-header-Datei hat den Namen GenericFactory.hpp

InformationsquelleAutor der Antwort texta83

---------------
Detail solution for registering the objects, and accessing them with string names.
---------------
1. common.h
#ifndef COMMON_H_
#define COMMON_H_


#include<iostream>
#include<string>
#include<iomanip>
#include<map>

using namespace std;
class Base{
public:
    Base(){cout <<"Base constructor\n";}
    virtual ~Base(){cout <<"Base destructor\n";}
};
#endif /* COMMON_H_ */

2. test1.h
/*
 * test1.h
 *
 *  Created on: 28-Dec-2015
 *      Author: ravi.prasad
 */

#ifndef TEST1_H_
#define TEST1_H_
#include "common.h"

class test1: public Base{
    int m_a;
    int m_b;
public:
    test1(int a=0, int b=0):m_a(a),m_b(b)
    {
        cout <<"test1 constructor m_a="<<m_a<<"m_b="<<m_b<<endl;
    }
    virtual ~test1(){cout <<"test1 destructor\n";}
};



#endif /* TEST1_H_ */

3. test2.h
#ifndef TEST2_H_
#define TEST2_H_
#include "common.h"

class test2: public Base{
    int m_a;
    int m_b;
public:
    test2(int a=0, int b=0):m_a(a),m_b(b)
    {
        cout <<"test1 constructor m_a="<<m_a<<"m_b="<<m_b<<endl;
    }
    virtual ~test2(){cout <<"test2 destructor\n";}
};


#endif /* TEST2_H_ */

3. main.cpp
#include "test1.h"
#include "test2.h"

template<typename T> Base * createInstance(int a, int b) { return new T(a,b); }

typedef std::map<std::string, Base* (*)(int,int)> map_type;

map_type mymap;

int main()
{

    mymap["test1"] = &createInstance<test1>;
    mymap["test2"] = &createInstance<test2>;

     /*for (map_type::iterator it=mymap.begin(); it!=mymap.end(); ++it)
        std::cout << it->first << " => " << it->second(10,20) << '\n';*/

    Base *b = mymap["test1"](10,20);
    Base *b2 = mymap["test2"](30,40);

    return 0;
}

------------------------
Compile and Run it (Have done this with Eclipse)
------------------------
/Output

Base constructor
test1 constructor m_a=10m_b=20
Base constructor
test1 constructor m_a=30m_b=40

InformationsquelleAutor der Antwort user3458845

Tor Brede Vekterli bietet eine boost-Erweiterung, die bietet genau die Funktionalität, die Sie suchen. Derzeit ist es etwas umständlich, Bestückung mit Strom-boost-libs, aber ich war in der Lage, um es arbeiten mit 1.48_0 nach der änderung seiner Basis-namespace.

http://arcticinteractive.com/static/boost/libs/factory/doc/html/factory/factory.html#factory.factory.reference

In Antwort auf diejenigen, die Frage, warum so ein Ding (als Reflexion) wäre nützlich für c++ - ich benutze es für die Interaktion zwischen der Benutzeroberfläche und dem ein-Motor - der Benutzer wählt eine option in der Benutzeroberfläche, und der Motor nimmt das UI-Auswahl-string, und erzeugt ein Objekt des gewünschten Typs.

Der Hauptvorteil der mit dem Rahmen hier (über die Aufrechterhaltung einer Frucht-die Liste irgendwo) ist, dass die Registrierung der Funktion ist in jeder Klasse die definition (und benötigt nur eine Zeile code aufrufen der Registrierung eingetragene Funktion pro Klasse) - im Gegensatz zu einer Datei mit der Frucht-Liste, die müssen manuell Hinzugefügt werden, jedes mal, wenn eine neue Klasse abgeleitet ist.

Ich habe die Fabrik eine statische member-meine base-Klasse.

InformationsquelleAutor der Antwort DAmann