Acceder a los miembros en una estructura de C++ de forma dinámica y estática

Question

Me gustaría tener una estructura (o algo similar) en C++, que permita el acceso a sus miembros de forma dinámica. Debería tener un getter y setters genéricos que reciban el nombre del miembro como una cadena, y devolver algún tipo de tipo de variante (por ejemplo, boost::variant).

Estaba pensando que podría implementarse usando boost::fusion::map, agregando una cadena que representa el nombre de cada miembro y construyendo un mapa STL entre cadenas y funciones getter o setter. No quiero reinventar la rueda, así que esperaba que algo similar ya existiera.

¿Qué opinas? ¿Funcionaría mi idea? ¿Conoces otras formas de lograr mi objetivo?

Gracias, Hageo

Answer 1

fusión es una aproximación, pero por qué no almacenar sus "campos" en un std::map introducido por un std::string, donde la carga útil es la boost::variant ...

es decir

struct generic 
{ 
std::map<std::string, boost::variant<foo, bar, bob, int, double> > _impl; 
}; 

y luego se puede solo busque la clave en su getter/setter ...

heck, envuelva el variant en un optional y podría tener campos opcionales!

un ejemplo más complejo:

class foo 
{ 
public: 
    typedef boost::variant<int, double, float, string> f_t; 
    typedef boost::optional<f_t&> return_value; 
    typedef map<string, return_value> ref_map_t; 

    foo() : f1(int()), f2(double()), f3(float()), f4(string()), f5(int()) 
    { 
    // save the references.. 
    _refs["f1"] = return_value(f1); 
    _refs["f2"] = return_value(f2); 
    _refs["f3"] = return_value(f3); 
    _refs["f4"] = return_value(f4); 
    _refs["f5"] = return_value(f5); 
    } 

    int getf1() const { return boost::get<int>(f1); } 
    double getf2() const { return boost::get<double>(f2); } 
    float getf3() const { return boost::get<float>(f3); } 
    string const& getf4() const { return boost::get<string>(f4); } 
    int getf5() const { return boost::get<int>(f5); } 

    // and setters.. 
    void setf1(int v) { f1 = v; } 
    void setf2(double v) { f2 = v; } 
    void setf3(float v) { f3 = v; } 
    void setf4(std::string const& v) { f4 = v; } 
    void setf5(int v) { f5 = v; } 

    // key based 
    return_value get(string const& key) 
    { 
    ref_map_t::iterator it = _refs.find(key); 
    if (it != _refs.end()) 
     return it->second; 
    return return_value(); 
    } 

    template <typename VT> 
    void set(string const& key, VT const& v) 
    { 
    ref_map_t::iterator it = _refs.find(key); 
    if (it != _refs.end()) 
     *(it->second) = v; 
    } 

private: 
    f_t f1; 
    f_t f2; 
    f_t f3; 
    f_t f4; 
    f_t f5; 

    ref_map_t _refs; 
}; 

int main(void) 
{ 
    foo fancy; 
    fancy.setf1(1); 
    cout << "f1: " << fancy.getf1() << endl; 

    fancy.set("f1", 10); 
    cout << "f1: " << fancy.getf1() << endl; 

    return 0; 
} 

Answer 2

Usted está solicitando Reflection en C++ que creo que no está disponible. Tendrás que inventar algo propio.

Answer 3

Lo que hice para esto era un tipo lista impulso :: contras similar que contiene mis miembros y algún tipo de descripción. Luego construyo este mapeo al agregar sucesivamente mis miembros a una estructura de datos de "metainformación" mediante llamadas a funciones "encadenadas". Todo parece muy similar a la definición de una clase en boost.python. Si realmente usa boost :: cons, también debería funcionar como una secuencia en boost.fusion, por lo que puede iterar muy bien sobre sus datos. Tal vez pueda usar un mapa boost.fusion para obtener los tiempos de acceso de registro (n) en tiempo de ejecución, pero parece que su tamaño es limitado hasta que estén disponibles las plantillas variadic.