structure : valeur ou adresse, efficacité

Salut,

Dans des procédures prenant en argument des structures que l'on veut accéder en lecture, quel est l'usage :

void proc1(struct type_struct ma_struct);
void proc2(struct type_struct *ma_struct);
void proc3(const struct type_struct *ma_struct);


Je dirais que proc3 est meilleure ? Sémantiquement l'objet pointé par ma_struct est intouchable, contrairement à dans proc2(). Je dirais que proc3 est également plus efficace que proc1() qui fait, lors de chaque appel, une copie membre à membre d'une structure vers une autre... ce que je pense est plus lent.


J'ai raison, j'ai tord ? Il y a autre chose ?


Merci
A bientot

Je pense exactement comme toi. Une structure se passe par adresse et pas par valeur. Si on ne doit pas la modifier (parce que cela n'a pas de sens pour la fonction appelée), on rajoute le mot clé const.

Donc oui : proc3

Disons que ça dépend de ce que tu veux rendre constant. Trois solutions possibles :

1) Seul l'objet pointé doit être constant (= en lecture seule) :

Code:

---

void proc3(struct type_struct const * ma_struct);

---

Cette écriture autorise à modifier le pointeur.

2) Seul le pointeur doit être constant :

Code:

---

void proc3(struct type_struct * const ma_struct);

---

Cette écriture autorise à modifier les membres de la structure.

3) Le pointeur et l'objet pointé doivent être constants tous les deux :

Code:

---

void proc3(struct type_struct const * const ma_struct);

---

============

D'une manière générale, const rend constant ce qui se trouve juste avant lui.
S'il se trouve au tout début (ce qui est autorisé), il a la même signification que s'il se trouvait juste après le type. Exemple :

Code:

---

void proc3(const struct type_struct * ma_struct);

---

correspond à la même chose que :

Code:

---

void proc3(struct type_struct const * ma_struct);

---

Citation:

---

Envoyé par Heimdall

Je dirais que proc3 est meilleure ? Sémantiquement l'objet pointé par ma_struct est intouchable, contrairement à dans proc2(). Je dirais que proc3 est également plus efficace que proc1() qui fait, lors de chaque appel, une copie membre à membre d'une structure vers une autre... ce que je pense est plus lent.

---

Si tu cherches à établir des règles de codage à l'échelle d'un projet entier, tu peux effectivement suivre ce principe. La pile est un espace essentiel, limité, et rarement protégé contre les débordements. Les règles de bon usage incitent donc à en faire un usage le plus sobre possible, sans compter le coûts en cycles de copies incessantes de grands blocs de données. Donc, dans le doute : proc3().

Maintenant, si c'est l'optimisation que tu recherches, il faut bien retenir que cela ne va devenir intéressant qu'à partir du moment où la structure aura une certaine taille. Si ta structure est aussi grosse que le pointeur, ça ne vaut pas le coup.

Si elle est plus grosse de quelques octets, ce n'est pas forcément très intéressant non plus, car il faudra de toutes façons faire, au niveau du code, une étape supplémentaire pour déréférencer le pointeur. Sur un PC, ça n'a pas beaucoup d'importance, mais dans l'embarqué ou la programmation de micro-contrôleurs, l'espace dédié au code est souvent aussi restreint que celui consacré à la pile… et n'est jamais libéré !

Enfin, il faudra tenir compte du fait que ton pointeur peut être NULL, ou invalide d'une manière générale. Et ça, c'est à ta fonction de le contrôler. L'avantage, dans ce cas, d'un passage direct par valeur est de garantir la lisibilité du contenu de la structure. Ça n'empêche pas ses membres d'être éventuellement incorrects eux-aussi, mais tu retires quand même une segfault potentielle et des étapes de maintenance.

Merci pour ces réponses utiles et précises :-)