Pointeurs sur Structure [Débutant]

Bonjour a tous,

Je m'exerce désesperemment sur l'utilisation des pointeurs mais j'éprouve toujours quelques difficultés a leurs utilisations. Je pense que le seul moyens d'y arriver est la pratique.

J'ai donc un petit doute quand a l'accès des données pour le code suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

typedef struct { int* DataPtr; int DataLength; }InfoType   void Function(int Buffer, InfoType* InfoPtr) {   int copy_buffer, copy_DataPtr, copy_DataLength;   copy_buffer = Buffer; copy_DataPtr = *InfoPtr.DataPtr; copy_DataLength = InfoPtr.DataLength; }

---

A l'appel de ma fonction, InfoPtr est défini comme pointeur sur la structure InfoType, qui elle même contient un pointeur sur un entier.

Je souhaite copier les données de la structure via ma fonction mais je ne suis pas sûr de mon code.

Qu'en pensez-vous?


Merci d'avance pour vos réponses et explications.

Cordialement,

Tu passes un pointeur à ta fonction, pour accéder à la donnée il faut donc une étoile.
Après pour avoir accès à la donnée pointée par DataPtr il faut une seconde étoile.

Code:

---

1 2	copy_DataPtr = (*(*InfoPtr).DataPtr); copy_DataLength = (*InfoPtr).DataLength;

---

Une étoile te permet de passer du pointeur à la zone mémoire pointée.
Sachant que si tu as un pointeur de pointeur :
- pas d'étoile = zone mémoire du pointeur
- une étoile = zone mémoire du pointeur pointé
- deux étoiles = zoné mémoire de la donnée

En espérant que je ne te dises pas de bêtises, je n'utilise pas de pointeur dans mon métier et donc mes connaissances sur ce sujet datent de l'école.

Pour les pointeur sur une structure, on utilise habituellement le symbole ->

Dans ton cas:

Citation:

---

InfoPtr->DataLength

---

:)

Salut,

Il faut que tu sépares le problème en sous-problèmes :

1. l'utilisation d'un pointeur sur structure
2. l'accès aux champs
3. l'utilisation des champs

Un pointeur sur structure, c'est comme n'importe quel pointeur : ça contient l'adresse d'une structure. C'est utile pour passer des structures en paramètres à des fonctions, car ça évite de copier toute la structure sur la pile d'appel : on ne copie qu'un pointeur.

L'accès aux champs d'une structure est indépendant du type des champs. Si tu utilises une structure directement, tu utilises le . ; si tu utilises un pointeur sur structure, tu peux déférencer le pointeur avec * et ensuite utiliser le . pour accéder aux champs mais la solution la plus souvent utilisées est la flèche ->. Exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

typedef struct { Type1 champ1; Type2 champ2; } ma_struct_t;   ma_struct_t direct; Type1 c = direct.champ1;   ma_struct_t *pointeur = &direct; c = (*pointeur).champ1; Type2 d = pointeur->champ2;

---

L'accès aux champs est indépendant du type des champs. Dans l'exemple précédent, tu remplaces Type1 par int et Type2 par int* si tu veux. c sera un int, d sera un int*. Tu les utilises ensuite pour ce qu'ils sont.

Pour en venir à ton code, il y a donc des erreurs que tu auras trouvée en lisant ce que je viens d'écrire :

• tu n'accèdes pas toujours de la même manière aux champs (une fois avec étoile, une fois sans)
• tu as un champ de type int* et tu lui affectes un int

Ton compilateur doit d'ailleurs de mettre des messages d'erreur non ?

Citation:

---

Je pense que le seul moyens d'y arriver est la pratique.

---

Je pense qu'il faut d'abord bien saisir les concepts et que ces concepts se digèrent mieux avec de la pratique. Ne fais pas l'effort de comprendre avec un stylo et une feuille comme cela marche ! ;)


@transgohan :

Code:

---

copy_DataPtr = (*(*InfoPtr).DataPtr);

---

Vu les noms des champs, je pense qu'il s'agit plutôt ici d'un mauvais type de la variable locale copy_DataPtr qui devrait être un int*.

Pour résumer :

Si on a une structure X du type InfoType, on a accès à ses champs par l'opérateur . (point) :

Code:

---

1 2	InfoType X ; X.DataLength = ...;

---

Si on a un pointeur pX sur une structure du type InfoType, il faut prendre l'objet à l'adresse contenue dans le pointeur (*pX). Cet objet est une structure InfoType et on a accès à ses champs comme ci-dessus :

Code:

---

1 2 3

InfoType X; InfoType * pX = &X ; (*px).DataLength = ...; // avec les parenthèses

---

Cette dernière écriture peut se simplifier par la notation habituelle :

Code:

---

px->DataLength = ...; // équivalent à (*px).DataLength.

---

En appliquant à ton exemple :

Code:

---

1 2 3 4 5 6 7 8

void Function(int Buffer, InfoType* InfoPtr) { int copy_buffer, copy_DataLength; int * copy_DataPtr; copy_buffer = Buffer; copy_DataPtr = (*InfoPtr).DataPtr; // ou InfoPtr->DataPtr; copy_DataLength = InfoPtr->DataLength; // ou (*InfoPtr).DataLength }

---

Code:

---

(*px).DataLength = ...; // avec les parenthèses

---

Je n'étais plus certain de la nécessité des parenthèses, merci pour la piqûre de rappel !

Bonjour a tous,

Tout d'abord, merci pour ces éclaircissements.

Donc si j'ai bien tout saisi, pour accéder a un pointeur sur structure de pointeur, il faut définir un pointeur qui sera egal au pointeur en entrée corréler avec l'argument de la structure?

Concernant ma fonction "Function", pour éffectuer un appel de cet dernière dans ma fonction main, il faudrait la définir de la manière suivante:

Code:

---

1 2 3 4 5 6 7 8

void main (void) { int Buffer1; InfoType InfoPtr1;   Function(Buffer1, &InfoPtr1); }

---

Merci d'avance,

8O

Citation:

---

Donc si j'ai bien tout saisi, pour accéder a un pointeur sur structure de pointeur, il faut définir un pointeur qui sera egal au pointeur en entrée corréler avec l'argument de la structure?

---

je ne comprend rien à cette phrase :P

Citation:

---

Concernant ma fonction "Function", pour éffectuer un appel de cet dernière dans ma fonction main, il faudrait la définir de la manière suivante:...

---

Oui, la trame est correcte.

Effectivement, ma phrase n'étais pas très explicite.

Autant résumer cela par un exemple plus claire. Je souhaite utiliser la function mecpy pour stocker les données en mémoire dans un buffer local.

memcpy ( void * destination, const void * source, size_t num );

Dans le cadre de mon exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

int buffer_data;     typedef struct { int* DataPtr; int DataLength; }InfoType   void Function(int Buffer, InfoType* InfoPtr) {   (VOID)memcpy(&(buffer_data), ((*InfoPtr).DataPtr), InfoPtr->DataLength);   }

---

Le fait est que j'ai toujours quelques doutes quand a l'adressage et le pointage des données. J'éprouve quelques difficultés a jouer avec cela pour le moment.

Merci d'avance pour vos réponses.

Cordialement,

Tu ne peux pas avoir &(InfoPtr.DataPtr). Puisque InfoPtr est un pointeur sur la structure, l'accès au champ DataPtr se fait avec -> comme ici InfoPtr->DataLength.

Après, tout dépend de ce que tu veux faire et ton code me donne des orientations conflictuelles.
Par exemple, si tu as dans InfoPtr->DataPtr l'adresse de départ d'un tableau de int que tu auras préalablement créé (par exemple par allocation dynamique) et si InfoPtr->DataLength est le nombre de BYTES alloués pour ce tableau, on aura :

Code:

---

1 2 3

int buffer_data[N]; // avec N suffisamment grand ... memcpy( buffer_data, InfoPtr->DataPtr, InfoPtr->DataLength);

---

Si tu veux copier un seul int dont l'adresse est dans InfoPtr->DataPtr, on aura :

Code:

---

1 2 3

int buffer_data; ... memcpy( &buffer_data, InfoPtr->DataPtr, sizeof buffer_data);

---

et InfoPtr->DataLength n'a pas d'utilité

Donc il te faut expliquer exactement le but du code que tu veux faire

Citation:

---

Envoyé par Bktero

Code:

---

(*px).DataLength = ...; // avec les parenthèses

---

Je n'étais plus certain de la nécessité des parenthèses, merci pour la piqûre de rappel !

---

Salut
C'est parce que les parenthèses sont obligatoires (cause priorité du point sur l'étoile) que l'opérateur "->" a été créé pour simplifier...

Dis comme ça c'est très logique ! ;)