Discussion :

[bKm M27]

Salut à toutes et à tous,
Quelle est l'idée principale pour créer un éditeur de propriétés (exemple inspecteur d'objets de c++builder ou delphi ou vs....) qui permet d'identifier les attributs de chaque objet (les instances d'objets qui sont dans la mémoire) et donne un moyen de modifier ses valeurs.
Merci d'avance

[Iradrille]

Hello,

Il faut savoir quel est le type de chaque variable, pour ça ya qu'une seule solution : compiler avec les informations de debug.
Ainsi tu sais de quel type est chaque variable et tu peux les interpréter correctement, pour la lecture / modification des valeurs c'est dépendant du système d'exploitation (ReadProcessMemory / WriteProcessMemory sous Windows par exemple). Il faut quand même faire attention à ce que le process soit en pause avant de les modifier par sécurité.

Les infos de debug sont propres à un compilo et te donneront le nom des variables aussi.
Regarde du coté de GCC / GDB, ça devrait te donner une idée.

[bKm M27]

Merci pour ta réponse,
Oui il est claire que la connaissance du type de chaque variables permet de les interpréter correctement et sans difficulté aussi. tu as dit pour connaitre le type de chaque variable il "y a qu'une seule solution : compiler avec les informations de debug" -> je n'ai pas bien saisi. mais si j'ai bien compris ton idée il faut récupérer l'adresse mémoire de chaque variables !!?

[Iradrille]

Ce que je veux dire c'est qu'en mémoire il n'y à aucune information, ni le nom, ni le type de la variable. Le programme sait à quelle adresse est chaque variable et sait comment l'interpréter (il connait son type), mais toi, en lisant la mémoire tu ne trouveras pas ces infos.

Je n'ai jamais regardé ça en détail, mais je suppose que les infos de debug (ajoutées à l'exe, ou créées dans un fichier à part) contiennent le type, le nom et l'adresse de pas mal de variables (toutes celles qui sont connues à la compilation). Pour les autres tu auras leur adresse (toutes les variables allouées sur le tas)en suivant des pointeurs (qui eux seront alloués sur la pile) et dont tu trouvera leur nom / type / adresse (probablement sous forme d'un offset) dans les infos de debug.

Si tu veux récupérer le contenu d'une variable (ou la modifier), alors oui il faut récupérer son adresse et aller lire / écrire à cette adresse (et interpréter les données correctement en fonction de son type)

edit: après tout dépend du niveau de généricité que tu veux.
Si tu cherches juste à afficher/modifier des objets d'un certain type CONNU

Code :

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

1
2
3
4
5
6
7
class Foo {
   int a;
   char b;
   float c;
 
   void bar() const { }
};

C'est beaucoup plus simple, en fonction de l'alignement tu calcules les offsets des attributs, par "défaut", ça doit être

Code :

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

1
2
3
4
Foo foo;
Foo::a == &foo
Foo::b == &foo::a + (sizeof(int)+3) / 4 * 4 == &foo + 4 généralement
Foo::c == &foo::b + (sizeof(char)+3) / 4 * 4 == &foo + 8

Ainsi dès que tu as l'adresse d'un objet Foo, tu peux l'interpréter et le modifier.

Pour généraliser ça, il ne faut pas hardcoder les offsets, mais les lire dans les infos de debug

[bKm M27]

Oui en voyant l'objet Foo sur le papier en peut déduire le nombre de ses variables et ses types et son ordre dans l'objet englobant. mais on connait rien sur un objet qui est dans la mémoire ainsi que les objets hérités. En plus on ne doit pas oublier le niveau de visibilité de chaque variable. pour moi je peux faire un éditeur statique de propriétés codé à l'aveugle mais je veux créer un éditeur dynamique qui se change selon l'objet sélectionné.
Voici un schéma qui illustre mes besoins de cet éditeur . Merci pour ton aide.

[Bousk]

Bonjour,

cela s'apelle de l'introspection, et c'est pas évident (pour ne pas dire carrément difficile) en C++.
La seule question valable est : pourquoi vouloir le faire en C++ ?!
La plupart des langages de script permettent ce genre de manopulations de manière assez aisée.
Qt permet aussi de manipuler les variables via Qml assez simplement.

[Iradrille]

Bonjour,

cela s'apelle de l'introspection, et c'est pas évident (pour ne pas dire carrément difficile) en C++.
La seule question valable est : pourquoi vouloir le faire en C++ ?!
La plupart des langages de script permettent ce genre de manopulations de manière assez aisée.
Qt permet aussi de manipuler les variables via Qml assez simplement.

D'un coup j'ai un doute !

On parle ici d'observer / modifier les objets du programme lui même ? Ou d'un autre programme (ce que j'ai compris, type debugger) ?

Car effectivement l'introspection en C++... pas facile (et pour le coup, rien à voir avec les infos de debug).

[bKm M27]

Bonsoir, merci pour votre participation .
Voila Iradrille on parle ici d'observer / modifier les objets du programme lui même car à partir du programme on crée des instances de différents objets et les emmagasiner dans un container (une liste, map...) visible par l'utilisateur. cela lui donne un accès à tous les objets instanciés (ces objets sont instanciés par l'utilisateur lui même).

[bKm M27]

Hola a todos
Pour ce problème je pense qu'il est faisable en c++; Check this ->
http://www.vollmann.com/pubs/meta/meta/meta.html