Czy istnieje sposób na utworzenie instancji obiektów z łańcucha zawierającego nazwę ich klasy?

Mam plik: Base.h

class Base;
class DerivedA : public Base;
class DerivedB : public Base;

/*etc...*/

i inny plik: BaseFactory.h

#include "Base.h"

class BaseFactory
{
public:
  BaseFactory(const string &sClassName){msClassName = sClassName;};

  Base * Create()
  {
    if(msClassName == "DerivedA")
    {
      return new DerivedA();
    }
    else if(msClassName == "DerivedB")
    {
      return new DerivedB();
    }
    else if(/*etc...*/)
    {
      /*etc...*/
    }
  };
private:
  string msClassName;
};

/*etc.*/

Czy istnieje sposób, aby w jakiś sposób przekonwertować ten ciąg na rzeczywisty typ (klasę), tak aby BaseFactory nie musiał znać wszystkich możliwych klas pochodnych i mieć if () dla każdej z nich? Czy mogę utworzyć klasę z tego ciągu?

Myślę, że można to zrobić w C # za pomocą refleksji. Czy jest coś podobnego w C ++?

Nie, nie ma, chyba że sam wykonasz mapowanie. C ++ nie ma mechanizmu do tworzenia obiektów, których typy są określane w czasie wykonywania. Możesz jednak użyć mapy, aby wykonać to mapowanie samodzielnie:

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>;

A potem możesz to zrobić

return map[some_string]();

Zdobycie nowej instancji. Innym pomysłem jest zarejestrowanie się typów:

// 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");

Możesz zdecydować się na utworzenie makra do rejestracji

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

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

Jestem pewien, że dla tych dwóch są lepsze nazwy. Inną rzeczą, która prawdopodobnie ma sens tutaj, jest shared_ptr.

Jeśli masz zestaw niepowiązanych typów, które nie mają wspólnej klasy bazowej, możesz boost::variant<A, B, C, D, ...>zamiast tego nadać wskaźnikowi funkcji zwracany typ . Jak jeśli masz klasę Foo, Bar i Baz, wygląda to tak:

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;

A boost::variantjest jak związek. Wie, jaki typ jest w nim przechowywany, sprawdzając, jaki obiekt został użyty do zainicjowania lub przypisania do niego. Zajrzyj do jego dokumentacji tutaj . Wreszcie użycie surowego wskaźnika funkcji jest również nieco przestarzałe. Nowoczesny kod C ++ powinien być oddzielony od określonych funkcji / typów. Możesz zajrzeć, Boost.Functionaby znaleźć lepszy sposób. Wtedy wyglądałoby to tak (mapa):

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

std::functionbędzie również dostępny w następnej wersji C ++, w tym std::shared_ptr.

Nie, nie ma. Moim preferowanym rozwiązaniem tego problemu jest utworzenie słownika, który odwzorowuje nazwę na sposób tworzenia. Klasy, które chcą zostać utworzone w ten sposób, rejestrują metodę tworzenia w słowniku. Jest to omówione szczegółowo w książce wzorców GoF .

Krótka odpowiedź brzmi: nie możesz. Zobacz te pytania SO, aby dowiedzieć się, dlaczego:

1. Dlaczego C ++ nie ma odbicia?
2. Jak mogę dodać odbicie do aplikacji C ++?

Odpowiedziałem w innym pytaniu SO dotyczącym fabryk C ++. Proszę, zobacz tam czy interesuje Cię elastyczna fabryka. Próbuję opisać stary sposób z ET ++ do używania makr, który świetnie się sprawdził.

ET ++ był projektem przeniesienia starego MacApp na C ++ i X11. W tym celu Eric Gamma itp. Zaczął myśleć o wzorcach projektowych

boost :: function ma dość elastyczny szablon fabryki: http://www.boost.org/doc/libs/1_54_0/libs/functional/factory/doc/html/index.html

Preferuję jednak generowanie klas opakowujących, które ukrywają mechanizm mapowania i tworzenia obiektów. Typowym scenariuszem, z którym się spotykam, jest potrzeba mapowania różnych klas pochodnych niektórych klas bazowych na klucze, gdzie wszystkie klasy pochodne mają dostępną wspólną sygnaturę konstruktora. Oto rozwiązanie, które do tej pory wymyśliłem.

#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

Generalnie sprzeciwiam się intensywnemu używaniu makr, ale zrobiłem tutaj wyjątek. Powyższy kod generuje wersje GENERIC_FACTORY_MAX_ARITY + 1 klasy o nazwie GenericFactory_N, dla każdego N od 0 do GENERIC_FACTORY_MAX_ARITY włącznie.

Korzystanie z wygenerowanych szablonów klas jest łatwe. Załóżmy, że chcesz, aby fabryka tworzyła obiekty pochodne BaseClass przy użyciu mapowania ciągów. Każdy z obiektów pochodnych przyjmuje 3 liczby całkowite jako parametry konstruktora.

#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);

Destruktor klasy GenericFactory_N jest wirtualny, aby umożliwić następujące działania.

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;

Zwróć uwagę, że ten wiersz ogólnego makra generatora fabrycznego

#define BOOST_PP_FILENAME_1 "GenericFactory.hpp"

Zakłada się, że ogólny plik nagłówkowy fabryki nosi nazwę GenericFactory.hpp

Szczegółowe rozwiązanie do rejestracji obiektów i uzyskiwania dostępu do nich za pomocą nazw ciągów.

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_ */

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_ */

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;
}

Skompiluj i uruchom (zrobiłem to z Eclipse)

Wynik:

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

Znaczenie odbicia jak w Javie. jest trochę informacji tutaj: http://msdn.microsoft.com/en-us/library/y0114hz2(VS.80).aspx

Ogólnie rzecz biorąc, wyszukaj w Google „odbicie c ++”

Tor Brede Vekterli zapewnia rozszerzenie doładowania, które zapewnia dokładnie taką funkcjonalność, jakiej szukasz. Obecnie jest to trochę niewygodne z obecnymi bibliotekami boost, ale udało mi się je uruchomić z 1.48_0 po zmianie jego podstawowej przestrzeni nazw.

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

Odpowiadając tym, którzy pytają, dlaczego coś takiego (jak odbicie) miałoby się przydać w c ++ - używam go do interakcji między UI a silnikiem - użytkownik wybiera opcję w UI, a silnik bierze ciąg wyboru UI, i tworzy obiekt pożądanego typu.

Główną zaletą korzystania z tego frameworka w tym miejscu (zamiast utrzymywania gdzieś listy owoców) jest to, że funkcja rejestrująca znajduje się w definicji każdej klasy (i wymaga tylko jednej linii kodu wywołującej funkcję rejestracji na zarejestrowaną klasę) - w przeciwieństwie do pliku zawierającego lista owoców, którą należy dodać ręcznie za każdym razem, gdy tworzona jest nowa klasa.

Zrobiłem fabrykę statycznym członkiem mojej klasy bazowej.

To jest wzór fabryczny. Zobacz wikipedię (i ten przykład). Nie możesz stworzyć typu per se z łańcucha bez rażącego hackowania. Dlaczego tego potrzebujesz?