Discussion :

[lesteph]

Bonjour,

J'aimerais remplir une structure d'éléments de différents type en faisant une boucle.

Exemple de structure :

Code :

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

1
2
3
4
5
6
7
    struct Object{
        char  Name[20];
        int   Regulator;
        int   PID ;
        float P ;
        char  Ext[10];
    };

J'aimerais avoir un tableau de pointeurs contenant l'adresse de base de la structure et le décalage de chaque éléments.

  pObject[0]  => adr de base de la structure (Name) : 100 (par exemple)
  pObject[1]  => offset Regulator                           : 20
  pObject[2]  => offset PID                                   : 22
  pObject[3]  => offset P                                      : 24
  pObject[4]  => offset Ext                                   : 28

Le but est d'avoir un tableau de structure et de pouvoir écrire :

 pObject[0][0] = "blablabla" ;
 *(pObject[0] + &pObject[0][1]) = 15 ;
 *(pObject[0] + &pObject[0][2]) = 22 ;
 *(pObject[0] + &pObject[0][3]) = 56.123 ;
 *(pObject[0] + &pObject[0][4]) = "hahaha" ;

Bien entendu ce code ne fonctionne pas ! Problème de type !
Et .. Il faudrait que j'utilise memcpy() pour copier le bon nombre de byte.

D'où ma question...
De quel type déclarer mon tableau pObject de pointeurs ? char * ou void * ?
Comment calculer les offsets des éléments ?

Merci pour vos solutions
Stéphane

[Obsidian]

Bonjour,

Le C propose <stddef.h> qui définit la macro offsetof() pour récupérer facilement les offsets des membres d'une structure. Le principe de cette macro consiste à transtyper l'adresse 0x00000000 vers un pointeur de ta structure, l'adresse de chaque membre étant alors égale à leur offset. La valeur renvoyée est de type « size_t ».

D'où ma question...
De quel type déclarer mon tableau pObject de pointeurs ? char * ou void * ?
Comment calculer les offsets des éléments ?

Ni l'un ni l'autre. Si ce sont des offsets que tu enregistres, alors ce doit être un tableau de « size_t ». Tu utilises ensuite ces valeurs entière à ce qu'elles sont : des offsets (nombres entiers) par rapport à une adresse de base (pointeur). Tu passes donc par l'arithmétique des pointeurs.

Par contre, le pointeur de l'adresse de base doit être de type char * pour être sûr que l'incrément soit bien de la largeur d'un byte. Une fois calculée l'adresse finale, il faut transtyper l'expression entière pour accéder au membre qui se trouve derrière.

[lesteph]

c'est TOP !! Merci !

C'est exactement ce que je voulais et avait besoin.