Accéder aux membres dans une structure C++ à la fois dynamiquement et statiquement

Question

Je voudrais avoir une structure (ou quelque chose de similaire) en C++, qui permettra l'accès à ses membres de façon dynamique. Il doit avoir un getter générique et des setters qui reçoivent le nom du membre sous forme de chaîne, et renvoyer un type de type variant (par exemple, boost::variant). Je pensais qu'il pourrait être implémenté en utilisant boost::fusion::map, en ajoutant une chaîne représentant le nom de chaque membre, et en construisant une carte STL entre les chaînes et les fonctions getter ou setter. Je ne veux pas réinventer la roue, alors j'espérais que quelque chose de similaire existait déjà.

Qu'en pensez-vous? Mon idée fonctionnerait-elle? Connaissez-vous d'autres façons d'atteindre mon objectif?

Merci, Aggée

Answer 1

fusion

est une approche, mais pourquoi ne pas stocker vos « champs » dans un std::map calée par un std::string, où la charge utile est le boost::variant ...

-à-dire

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

et vous pouvez il suffit de rechercher la clé dans votre getter/setter ...

heck, envelopper le variant dans un optional et vous pourriez avoir des champs optionnels!

un exemple plus complexe:

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

Vous demandez Reflection en C++ que je pense n'est pas disponible. Vous devrez trouver quelque chose de votre choix.

Answer 3

Ce que je l'ai fait pour cela était un type liste boost :: comme le contre qui contient mes membres et une sorte de description. Je construis ensuite cette cartographie en ajoutant successivement mes membres à une structure de données «méta-info» par des appels de fonction «chaînés». Le tout ressemble beaucoup à la définition d'une classe dans boost.python. Si vous utilisez en fait boost :: cons, cela devrait aussi fonctionner comme une séquence dans boost.fusion, donc vous pouvez bien parcourir vos données. Peut-être que vous pouvez utiliser une carte boost.fusion à la place pour obtenir des temps d'accès au journal (n) au moment de l'exécution, mais il semble que leur taille soit limitée jusqu'à ce que des modèles variés soient disponibles.