Adresse d'une structure inconnue

**will74** · 05/01/2011, 01h15

Bonjour a tous, et Bonne Annee ^^

Je viens vers vous aujourd'hui afin de vous demander un peu d'aide.
Je me retrouve en effet face a une problématique concernant les structure et les pointeurs en C.

Pour faire court et être concis, je cherche a déterminer l'adresse d'une structure a partir de l'adresse (pointeur) de l'un de ses membres.
Le nombre de membres est indéterminé, autant dire que je ne peut pas me baser sur la taille de ses membres.

De plus, je ne pas comment déterminer le "début" dans le cas ou je pourrais successivement déterminer la taille des éléments "parents" de l’élément dont j'ai l'adresse.

Voila pourquoi je me retrouve bloque.

Je manipule assez bien les pointeurs lies aux structures, mais si l'un d'entre vous saurait me donner une piste...

Merci d'avance

wILL

**droggo** · 05/01/2011, 02h17

Nai,

Ben ...

Si tu ne connais pas l'offset de l'adresse dont tu disposes dans la structure, et que tu n'a pas de moyen pour le récupérer, c'est un peu demander l'altitude absolue du point où je me trouve actuellement, sans autre référence, non ?

**diogene** · 05/01/2011, 10h38

Si tu ne connais pas le type exact de la structure, tu ne peux rien faire.
Sinon, la connaissance de la taille des différents membres de la structure ne te sera d'aucune aide et il faut te tourner vers offsetof() (<stddef.h>)

**uknow** · 05/01/2011, 12h38

Bonjour,

Ce qu'il faut savoir : "un pointeur sur une structure est un pointeur sr son premier élément". Le mot élément sous-entend également les champs de bits :

Within a structure object, the non-bit-field members and the units in which bit-fields reside have addresses that increase in the order in which they are declared. A pointer to a structure object, suitably converted, points to its initial member (or if that member is a bit-field, then to the unit in which it resides), and vice versa. There may be unnamed padding within a structure object, but not at its beginning.

Sinon je rejoins l'avis des autres, à savoir, que si la fonction ne voit pas la définition de la structure elle ne peux rien faire de façon sûre et portable. Pour finir, la taille d'une structure n'est pas forcément la somme des tailles de ses membres (c'est même rare que ce soit le cas).

Peut être en nous fournissant plus de détails sur le contexte on arriverait à te proposer une alternative.

**will74** · 05/01/2011, 13h13

Suite a la lecture de vos réponses je ne sais pas quoi vous dire.
Voila l’énonce de ce que je tente de faire.

Creer la fonction get_struct_ptr qui a le prototype suivant :

Code :

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

 t_whatever   *get_struct_ptr(int *member_ptr);

t_whatever etant definie de la maniere suivante :

Code :

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

1
2
3
4
5
6
  typedef struct       s_whatever
   {
     ...
     int        member;
     ...
   }            t_whatever;

Les '...' veulent dire que l'on peut mettre n'importe quels champs dans
la structure 's_whatever' avant et apres le champ 'member'.
Un exemple de structure 's_whatever' est donne dans
le fichier 'ptr_tricks.h'.

La fonction 'get_struct_ptr' prend donc en parametre un pointeur sur
le champ 'member' d'une structure 's_whatever' et doit
tout simplement renvoyer un pointeur sur cette structure.

**uknow** · 05/01/2011, 13h25

Au risque de créer un débat, je doute de l'utilité d'un tel exercice; en C, je ne vois pas où est-ce que cela peut-il être significatif. Car si je peux envoyer l'adresse d'un membre de structure, alors je peux envoyer l'adresse de la structure même

.

Sinon la solution que je vois, est que tu définisse une variable de type t_whatever, que tu regarde le décalage entre ce même membre passé en argument et l'adresse initiale de cette variable; pour ensuite appliquer ce décalage au pointeur que tu as reçu en paramètre.

Tu pourrais utiliser un char* pour éviter des problèmes d'arithmétiques des pointeurs.

(Je te mettrai un exemple plus tard; mais tu peux déjà y réfléchir).

**will74** · 05/01/2011, 13h29

Plop.

Le sujet n’étant pas très explicite, je ne sais pas si cela est faisable.
Sinon je pense avoir compris l’idée. Je vais essayer cela cet aprem, et je ferais un retour dans la soirée

Merci a toi

wILL

**uknow** · 05/01/2011, 13h46

Voici une version :

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
#include <stdio.h>
#include <stddef.h>
 
typedef struct
{
    char t[5];
    unsigned long int ul;
 
    int indicateur;
 
    float f;
    double lf;
 
} t_whatever;
 
t_whatever * get_struct_ptr(int * indic);
 
int main(void)
{
	t_whatever s;
 
	printf("&s = %p\tget_struct_ptr() = %p\n",(void*)&s,(void*)get_struct_ptr(&(s.indicateur)));
 
	return 0;
}
 
t_whatever * get_struct_ptr(int * indic)
{
    t_whatever s;
    ptrdiff_t decalage = (void*)&(s.indicateur) - (void*)&s;
 
    char * tamp = (char*) indic;
 
    if(!tamp)
        return NULL;
 
    return (t_whatever*)(tamp - decalage);
}

(Il peut y avoir des choses à dire sur la portabilité

).

**will74** · 05/01/2011, 15h09

Merci pour ta précieuse aide.
J'avais fait quelque chose dans le style, mais ton code est plus clair, et je pense que l'utilisation du type ptrdiff_t est approprie dans le cas de cet exercice.

Merci beaucoup

wILL

**diogene** · 05/01/2011, 16h16

Code :

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

ptrdiff_t decalage = (void*)&(s.indicateur) - (void*)&s;

Ce genre d'opérations entre void * n'est pas standard (puisqu'elle nécessite de connaitre le type de l'objet pointé)

Peut être remplacé par

Code :

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

ptrdiff_t decalage = offsetof(t_whatever,indicateur) ;

ce qui supprime en même temps la raison d'être de l'objet s.

**uknow** · 05/01/2011, 16h31

Bien vu. Dans ce cas :

Code :

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

size_t decalage = offsetof(t_whatever,indicateur) ;

Ou sinon faire une conversion en char* au lieu de void* :

Code :

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

ptrdiff_t decalage = (char*)&(s.indicateur) - (char*)&s;

Les types char* et void* sont tellement liés historiquement que je les ai confondus (en ce qui est de l'arithmétique). Ce qui est étonnant dans cette affaire c'est qu'ils subissent les mêmes règles d'alignement pourtant.