Pointeur sur structure

Bonjour,

C'est quoi la différence entre les deux codes, et que ce que je peux gagner comme mémoire?

/**************code 1 ****************/
je déclare defaut de type tCodeDefaut

Code:

---

1 2 3 4 5 6 7

typedef struct { int code; char description [255]; } tCodeDefaut;   tCodeDefaut defaut;

---

je passe l'adresse de defaut a la fonction de GenererCodeDefaut

Code:

---

GenererCodeDefaut (&defaut);

---

/**************code 2 ****************/
je déclare defaut de type pointeur sur tCodeDefaut

Code:

---

1 2 3 4 5 6 7

typedef struct { int code; char description [255]; } tCodeDefaut;   tCodeDefaut *defaut;

---

je passe l'adresse de defaut a la fonction de GenererCodeDefaut

Code:

---

GenererCodeDefaut (defaut);

---

/**************************************/

Si le même chose, parce que j'ai lit dans des cours C avancé que passer à une fonction un variable de type structure sa prend beaucoup en RAM
par contre passer un pointeur sur structure va être charger dans le stack
et va être plus économique en mémoire

merci d'avance

Hum...! Disons qu'on pourrait prendre un exemple de la vie courante pour mieux comprendre.

Imaginons que nous ayons une voiture qui a besoin de réparation. D'après toi, qu'est-ce qui va prendre le plus de temps ?

1. Récupérer l'adresse du garagiste et s'y rendre,
2. déplacer le garage, avec tous les outils, le réparateur, les bâtiments... jusqu'à la voiture.

Il me semble qu'il est bien plus pratique et performant d'amener la voiture au garagiste et non l'inverse.

Ceci dit il y a encore un soucis à transmettre une donnée directement. En C cette donnée est transmise par copie. Ce qui signifie que toute modification de la donnée transmise n'aura aucun effet au retour de la fonction sur la donnée passée.

Bonjour,

excellent exemple

par contre dans les deux codes j'ai envoyé à la fonction l'adresse de variable defaut !!!!

Merci d'avance

Il y a comme différence que dans le code 2, tu passe la valeur d'un pointeur, mais que ce pointeur n'a pas été initialisé auparavant avec l'adresse d'une structure tCodeDefaut : créer un pointeur ne crée pas l'objet pointé. Il aurait fallu avoir :

Code:

---

1 2 3 4 5 6 7 8 9

typedef struct { int code; char description [255]; } tCodeDefaut;   tCodeDefaut uneStructCodeDefaut; tCodeDefaut *defaut = &uneStructCodeDefaut; GenererCodeDefaut (defaut);

---

Alors, les deux codes sont équivalents et dans les deux cas, on passe l'adresse d'une structure (et non pas la structure)

Bonjour,

je veux savoir mieux techniquement (en terme de mémoire et de vitesse d'exécution ) la différence entre le passage à une fonction une structure et un pointeur sur structure (les emplacements dans le RAM, Stack...)

Merci d'avance

Les arguments passés à une fonction donnent lieu à
- création d'une variable locale du type correspondant au paramètre de la fonction
- copie de l'argument correspondant dans cette variable.

1- Si on passe une structure, une structure de même type va être créée sur la pile et la structure en argument copiée dedans

2- Si on passe une adresse de structure, un pointeur sur structure va être créé sur la pile et l'adresse de la structure copiée dedans

Evidemment, si la structure est un peu volumineuse, la solution 1 va être pénalisante en temps et en occupation mémoire et on préfère la solution 2.

On peut également montrer, dans la solution 2, qu'en fait c'est uniquement le contenu de la structure qui intéresse et qu'on ne veut pas pour autant le modifier en utilisant le modificateur const dans la déclaration des paramètres :

Code:

---

void GenererCodeDefaut ( const tCodeDefaut * codedefaut);

---

Ah, ça c'est excellent. Merci Diogène de nous indiquer (ou rappeler des choses comme ça. L'attribut const est un commentaire super utile pour tout développeur qui lit le code (en plus de ce que le compilateur peut en faire).

Commentaire un peu hors-sujet:
Le problème c'est que (des études le montrent, et un peu de raisonnement aussi), la quasi-totalité des paramètres de fonction proprement dits sont toujours inchangés, et ça n'aurait pas de sens de les changer de toute façon. (Ça va d'ailleurs bien avec le sens de "paramètre".) Le contre-exemple, c'est une une fonction (ou plutôt une action) dont le rôle est précisément de modifier ce sur quoi elle s'applique ; et dans ce cas-là cette variable n'est pas un paramètre. Par exemple, stocker dans un set un nouvel élément.
Alors, ce qui serait utile, c'est d'inverser le standard pour mettre les paramètres const par défaut. Sinon, pour être cohérent, on devrait mettre const sur presque tous les paramètres, mais ça pollue complètement le code (et de toutes façon, on le sait qu'il sont presque tous const, logiquement).
Par contre l'info inverse que tel paramètre (généralement le premier et lui seul), de ces fonctions spéciales qui sont en fait des actions, est une variable dynamique, ça ça serait une info utile. Qu'en pensez-vous ? (En plus, ça permet au compilo d'optimiser tranquille en passant en douce un pointeur même si nous on l'écrit pas comme ça.)

Denis

Citation:

---

Sinon, pour être cohérent, on devrait mettre const sur presque tous les paramètres, mais ça pollue complètement le code....

---

On sait qu'en C les paramètres sont toujours passés par copie. Par conséquent, la fonction ne peut jamais modifier les arguments passés aux fonctions.
D'autre part, les déclarer const ne voudrait pas dire que l'argument passé à la fonction est non modifiable, mais que la variable locale correspondant au paramètre est non modifiable. Ce qui n'a d'intérêt qu'à l'intérieur de la fonction.
Comme pour les autres variables locales, il est assez rare qu'on prenne la peine de les déclarer const surtout dans les petites fonctions.

La seule situation qui pose question est lorsque le paramètre est du type X* et où la fonction peut modifier ou non l'objet de type X dont l'adresse est en argument. C'est là que le qualificateur const peut être vraiment utile car il est informatif pour la fonction et pour l'utilisateur de la fonction.