Réflexion, templates et essai

**tir0nik** · 17/02/2011, 22h22

Bonjour à tous,

Je me suis "amusé" à tenter de faire de la "réflexion" en c++, c'est à dire manipuler des objets à partir d'un ensemble d'objets... pas très clair mais bon.

Seulement, il faut manipuler les templates à tout va, je me retrouve rapidement avec un code dégelasse.

Dans mon code, il y a plusieurs problèmes.

l'énorme répétition du code pour l'enregistrement des méthodes.
en effet, il faut une classe pour "sans paramètre", une classe pour "1 paramètre", une classe pour "2 paramètres"... et on double ça pour gérer le cas où le type de retour est void. D'où la première question comment simplifier ça ? (fichier methods.h)

Le trop gros nombre de "reinterpret_cast<>", j'ai l'impression que ça pourri mon code, est-ce que vous voyiez un moyen de les virer?

Le fait que les types soit intransigeants, c'est à dire que si votre méthode à un paramètre de type int et que vous envoyiez un double, ça va pas marcher, il n'y aura pas de cast implicite. C'est dû aux reinterpret_cast<>, raison de plus de les faire disparaître.

Pour enregistrer une méthode, je dois spécifier si un paramètre est une référence ou un pointeur. Je créer donc une liste de "Policies".
J'ai vu que typeid(T).name() renvoie une chaine avec toutes ces infos (type, référence/valeur/pointeur,..). C'est portable, ça vaut le coup de faire un parseur pour gérer ça automatiquement ?

Pour donner un avant goût, voici ce que fait mon code

(la partie intéressante est dans le main, en bas)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
#include "objectregister.h"
using namespace std;
 
 
/*
    Objet pour l'exemple
*/
class MyRootObject{
    public :
        void show(){
            std::cout<<"I am the root."<<std::endl;
        }
};
 
/*
    Objet pour l'exemple
    Manipule un entier
*/
class MyObject : public MyRootObject{
 
    int t;
 
    public:
 
        MyObject():t(10){}
 
        void set(int& n){
            t = n;
            n = 2 * n + 2; //pour tester si le passage par référence marche
        }
        int get(){
            return t;
        }
        void show(){
            std::cout<< "show" << " : " << t <<std::endl;
        }
};
 
int main()
{
    Object<MyRootObject> myRootObject("MyRootObject");//on déclare l'objet
    myRootObject.method("show",&MyRootObject::show);//on déclare sa methode show
 
    Object<MyObject> myObject("MyObject"); //on déclare l'objet MyObject
    myObject.extends(&myRootObject); //qui dérive de MyRootObject, on doit le lui dire
    myObject.method("set",&MyObject::set,arg(1,ref)); //on enregistre la méthode, le premier argument est une référence
    myObject.method("get",&MyObject::get);
    //myObject.method("show",&MyObject::show);  //Si cette méthode n'est pas déclaré, la méthode parent sera appelée
                                                //Si on met la méthode show de MyRootObject "virtual" alors c'est celle de
                                                //MyObject qui sera appelée (logique).
                                                //Si on la déclare, c'est celle-là qui sera appelée
 
    MyObject* obj = myObject.construct();//pour l'instant ne support que la construction sans paramètre
 
    std::cout << myObject.call<int>(obj,"get") << std::endl; //on appelle la méthode get de l'objet crée, et on affiche le retour
 
    ParamList params; //une liste de paramètres
    Policies police = myObject.getPolicies("set");//les "polices" de la méthode (pour savoir si c'est une méthode, un pointeur,..)
 
    int val = 6;
    params.add(val,police[1]);  //on ajoute à la liste. police[1] où 1 est le premier paramètre voir déclaration de MyObject::set
                                //Note : 0 -> la valeur de retour
 
    myObject.call(obj,"set",&params);//on appelle la fonction avec les paramètre
    myObject.call(obj,"show");//on affiche la nouvelle valeur de obj, graçe à une fonction interne.
    std::cout << val << std::endl;//on se rappelle que set modifie la valeur d'entrée, on vérifie que ça marche bien.
    params.deleteAll(); //nom temporaire, permet de vider ParamList, pour une prochaine utilisation.
                        //Est aussi appelé dans le destructeur, donc il n'y en aurait pas besoin ici, mais c'est pour l'exemple.
 
    return 0;
}