Discussion :

[LastSpear]

Bonjours a tous developpeurs

Je chercher un moyen de récupérer l'adresse d'un élément contenu dans objet : je m'explique.

Posont une class :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class MA_CLASS
{
public:
unsigned int A ;
unsigned char B ;
unsigned int C ;
 
 
};

Je voudrais en faite obtenir l'adresse relative de l'élément B par rapport à l'adresse de MA_CLASS, et ce à la compilation. Qui, dans ce cas, me retourne 4.

l'idéal serait qu'elle soit sous la form d'une macro :

Code :

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

1
2
3
4
 
ma_macro (MA_CLASS, A) // qui dans ce cas me retournera 0
ma_macro (MA_CLASS, B) // qui dans ce cas me retournera 4
ma_macro (MA_CLASS, C) // qui dans ce cas me retournera 5

La la classe est très simple, mais je dispose de class beaucoup plus "charnu" en membres de type variées, alors j'aimerai que dès lors que j'édite ma class, je n'ai pas besoin de réédité toute les adresses relatives manuellement.

En espérant que vous m'aillez compris, Savez vous faire çà ?

[cob59]

Le C++ ne gère pas l'introspection, donc si on souhaite qu'une table nous renseigne sur l'ordre et la taille des attributs d'une classe, il faut la créer soi-même pour chaque classe (possiblement dès la compil, avec un peu de metaprog).

Pendant le runtime et à condition qu'un objet soit alloué, on peut procéder comme ceci :

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
template <class C, typename Attr>
size_t attr_offset(const C* obj, const Attr* attr) {
size_t distance = (char*)attr - (char*)obj;
assert (distance < sizeof(C));
return distance;
}
 
#define OFFSET(obj,attr) attr_offset(&obj, &obj.attr)
 
struct S {
 int a;
 float b[16];
 double c;
} s;
 
std::cout << OFFSET(s,c) << std::endl;

Code :

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

Affiche : 68

A noter que le premier élément ne sera pas forcément à l'adresse 0 (table virtuelle).

[Neckara]

En C++ ne vas-t-on pas plutôt utiliser des fonctions/méthodes inlines à la place des macro?

[LastSpear]

Le C++ ne gère pas l'introspection, donc si on souhaite qu'une table nous renseigne sur l'ordre et la taille des attributs d'une classe, il faut la créer soi-même pour chaque classe (possiblement dès la compil, avec un peu de metaprog).

D'acore, bien compris, mais dommage en même temps car le compilateur lui se sert de ces adresses relatives pour avoir accès au élément d'un objet avec les instructions mov.

Pendant le runtime et à condition qu'un objet soit alloué

Oui justement c'est ce que j'ai pour le moment, mais j'aimerais ne pas avoir forcement d'objet alloué.

A noter que le premier élément ne sera pas forcément à l'adresse 0 (table virtuelle).

Oui bien sur, de taille même différente si on est en 32bits ou 64bits si je ne me trompe pas.

En C++ ne vas-t-on pas plutôt utiliser des fonctions/méthodes inlines à la place des macro?

En effet, l'un ou l'autre ne me dérange absolument pas.

[gbdivers]

Le besoin est étrange. C'est pour quel contexte, si c'est pas indiscret ? (d'autant plus que tu postes dans le forum "Débuter")

[LastSpear]

C'est bon, j'ai trouvé la solution idéal !

IBM C++

Je savais pas que çà fonctionnait aussi avec les éléments, mais c'est au poil !

Merci de vos interventions, je marque le sujet en résolut.

[LastSpear]

Désolé du double post, gbdivers : t'a eu le temps de posté pendant que j'écrivais

En fait c'est pour la gestion d'événements et l'envoi d'ordres d'objet maître à des objet exclaves. Ces derniers dispose d'élément comportant tout les information nécessaire au bon fonctionnement pour l'appel de certaine de leur fonctions.

Voici un petit bou de code vite programmer pour présenté la chose : (@WEBMASTER: sa serait bien de géré la touche TAB dans le textarea, je sais que c'est possible avec des scripts JS)

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
 
class MA_CLASS
{
public:
 
CORE::TASK::INPUT <MA_CLASS> OrderInput0 ;
CORE::TASK::INPUT <MA_CLASS> OrderInput1 ;
 
struct MES_ARGUMENTS
{
[...]
};
 
int maFonction0 (MES_ARGUMENTS * pMonPtr)
{
[...]
 
return 1 ;
}
 
int maFonction1 (MES_ARGUMENTS * pMonPtr)
{
[...]
 
return 1 ;
}
 
MA_CLASS ()
{
OrderInput0.init (&MA_CLASS::maFonction0);
OrderInput1.init (&MA_CLASS::maFonction1);
}
 
};
 
 
// appel
 
MA_CLASS * pMonObjet = new MA_CLASS ;
 
CORE::TASK::call (&TheardTaskBuffer, pMonObjet, &MA_CLASS::OrderInput0);

Bon vous me direz que sa ressemble beaucoup à des fonctions virtuel, mais en vérité, il y a beaucoup plus de paramètre pour les élément du type CORE::TASK::INPUT. et là le &MA_CLASS::OrderInput0 est utilisé même si un objet est instancié, mais j'ai ensuite des structure qui liste des pointeurs d'instance vers un même type d'objet, et qui soccupe d'appeler, &MA_CLASS::OrderInput0 de tout les objets qu'il pointes.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
CORE::TASK::INPUT_LIST <MA_CLASS> MonInputList ;
 
MA_CLASS * pMonObjet0 = new MA_CLASS ;
MA_CLASS * pMonObjet1 = new MA_CLASS ;
 
MonInputList.attache (pMonObjet0);
MonInputList.attache (pMonObjet1);
 
MonInputList.call (&TheardTaskBuffer, &MA_CLASS::OrderInput0);
 
/*
bon la dans une même procédure, ça na pas beaucoup d'intérêt. L'idée est que CORE::TASK::INPUT_LIST <MA_CLASS> soit membre d'un objet maitre, et que ensuite, sur chaque instance d'un objet exclave, ce dernier vient s'enregistrer dans la classe maitre, et comme çà, lorsque la classe maitre exige, il envoie le taff à tout ses objets exclaves, mais sur d'autre threads pour l'aspect aspect asynchrone.
*/

C'est pour un nouveau système pour géré le chargement On-the-fly pour mon moteur de rendu temps réel sur d'autre threads. Un peut comme le fonctionnement d'evement de Qt avec ses slots, mais en plus approfondit.

Debutant car ce dont j'avais besoin pour finir sa réalisation, était une question de syntaxe ou de techniques. Je m'attendait à une opérateur identique à sizeof personnellement.