novembre
2009
Introduction
Les mots clefs volatile ou mutable ne vous disent rien ? C’est normal ! Aujourd’hui, nous allons traiter des mots clefs qui ne servent quasiment jamais (parfois à tort), j’appelle : Les mots clefs poilus !
Comme d’hab, une version PDF est aussi disponible ici !
auto
Officiellement : Déclarateur de variable à désallocation automatique.
Commençons fort avec ce joli mot clef qui, pour le coup, ne sert vraiment à rien puisqu’il spécifie le même comportement que celui par défaut d’une variable locale i.e. qui est d’être détruite à la fin de la portée. Il va donc indiquer au compilateur que : «Bah oui, c’est une variable locale, faudra la détruire à la fin de ta porté... »
explicit
Officiellement : Interdit les constructeurs pour casts implicites.
Plus dur. Mais qui cette fois sert vraiment ! Avant tout, il faut savoir que par défaut, un constructeur ne prenant qu’un seul paramètre effectuera une conversion implicite (i.e. à la compilation et invisible pour l’utilisateur) si nécessaire. C’est ce mécanisme qui vous permet par exemple de faire :
Complex z = 2 // Initialise z avec Complex(2) alors que typeof(2) = int
Cependant, certaines situations sont très génantes tel que :
std::string S = 'a' // Definit S comme une chaine avec 97 éléments reservés en mémoire (int('a') = 97 )
Le mot clefs explicit permet d’empêcher le compilateur de faire la conversion et fait donc planter la chaine de compilation si une conversion implicit à été tentée.
il s’utilise de cette façon :
explicit MaClasse(const MaClasse& MonParam){ // MonParam sera obligatoirement du type MaClasse (par reference)
// Code de construction
}
mutable
Officiellement : Rend une partie d’un objet constant modifiable.
Ce mot clef est subtil mais peut servir une ou deux fois. Il est là lorsque un attribut ne peut jamais être const. Par exemple, considérons un objet ayant une durée de vie limitée. L’objet peut tout à fait être const ainsi que tout ses membre,sauf son compteur qui lui sera mutable, i.e., qu’il ne pourra jamais être constant. Ce mot clef peut aussi être util dans le cadre d’objet à mémoire cache.
register
Officiellement : Déclarateur de variable registre.
Pourrait être très pratique en théorie ! En effet, le mot clef register demande au compilateur de placer la variable dans un registre mémoire, qui est une zone mémoire très rapide en I/O. Cependant, il est très rare qu’il trouve un registre libre pour stocker la variable.
Mais faut avouer que quand ça passe, ca fait plaisir aux performances :
real 0m3.327s
user 0m3.320s
sys 0m0.010s
real 0m0.995s
user 0m0.970s
sys 0m0.000s
Une différence de l’ordre de 340% de rapidité en plus !
Pour un code du type :
int main() {
int i = 0;
for(i = 0; i < 1000000000; ++i);
return 0;
}
// TestRegister.cpp
int main() {
register int i = 0;
for(i = 0; i < 1000000000; ++i);
return 0;
}
volatile
Officiellement : Déclarateur de membre critique nécessitant un traitement d’actualisation particulier notamment lors de l’utilisation de threads.
Concretement, une variable volatile pourra être modifier par le matériel, le système d’exploitation ou un autre thread. Pour vous c’est simplement une indication au compilateur, mais pour lui, il devra garder une structure mémoire ainsi qu’un système de référence constant au cours de l’exécution. Il ne pourra pas non plus spéculer quant à la valeur d’une variable. Je ne rentrerais pas plus dans les détail car ce seul mot clef à fait écrire des bouquins entiers !
Conclusion
C’est déjà la fin de ce bref article, mon second ! J’espère qu’il vous a plu et qu’il donnera lieu à des retours sur le blog !
Enfin, comme pour mon premier article, n’hésitez pas à me dire si j’ai tort, je ne suis qu’en 3ème année et j’ai encore beaucoup de choses à apprendre. Je serai ravi d’ajouter votre contribution à mon article !
Merci à tous.
Références
La langage C++
Auteur:Bjarne Stroustrup
Editeur : Pearson Education; Édition : 2nd Revised edition (16 juin 2004)
ISBN-10: 2744070033
ISBN-13: 978-2744070037
13 Commentaires + Ajouter un commentaire
Commentaires récents
- Avez vous déjà vu ? Des mots clefs poilus ? Maintenant, oui ! dans
- Avez vous déjà vu ? Des mots clefs poilus ? Maintenant, oui ! dans
- Avez vous déjà vu ? Des mots clefs poilus ? Maintenant, oui ! dans
- Avez vous déjà vu ? Des mots clefs poilus ? Maintenant, oui ! dans
- Avez vous déjà vu ? Des mots clefs poilus ? Maintenant, oui ! dans
[r0d]
Je m’excuse si mes propos te sont parus accusateurs, mais je voulais juste apporter une précision, sans plus. D’autant plus que je trouve ton papier très bien.
Et merci pour ta réponse sur auto
[r0d] Une fois pour toute, je n’ai pas dit que ces mots clefs étaient inutiles, j’ai dit qu’on ne les utilisait que très rarement. a plus forte raison pour mutable.
Pour auto, en effet, la norme 0x (1x ?) lui confie de rôle d’autotypage. En gros, auto i = 0; se transforme après compilation en int i = 0; Pas mal hein ?
[Luc Hermitte] Il semble de plus en plus évident que volatile n’a pas trop son utilité dans un contexte multithreadé. je continuerai mes recherches et mettrai à jour l’article. Merci pour toutes ces informations.
Maxime Gaudin.
mutable peut être fort utile pour debugger/optimiser: on peut ajouter des compteurs, des marqueurs, toutes sortes de choses, et en les déclarant mutable, on a pas besoin de toucher à la const-conformité (por ainsi dire) du programme.
Quant à auto, il n’y a pas une histoire qu’il va changer de signification pour le prochain standard?
Au fait, le retour de la vengeance de la question: http://groups.google.fr/group/comp.lang.c++.moderated/browse_frm/thread/2348a0495c521f32 (c’est tout frais)
Le thread n’est pas encore trop pollué, les réponses de Dietmar Kuelh et d’autres ne sont pas (encore?) noyées sous les légendes urbaines.
Hum … « Microsoft Specific » entre chevrons a été consommé comme une balise, qu’il n’est pas et donc ignoré sur la première ligne de mon précédent message.
…
Prenons plutôt : http://www.hpl.hp.com/personal/Hans_Boehm/c++mm/faq.html
Il y a plein d’autres explications du même acabit sur google, comme ici par exemple: http://www.safercode.com/blog/2009/02/24/volatile-c-keyword-myths-dispelled.html
Pour le MT, std::atomic servira à quelque chose d’utile. volatile ? que nenni.
Bonjour,
Pour volatile et thread, je pense qu’on peut dire que ça sert à quelque chose dans un contexte multithread. Il suffit de regarder la page de description MSDN avec l’exemple justement dans un contexte multithread pour s’en convaincre : http://msdn.microsoft.com/fr-fr/library/12a04hfd.aspx.
Quant à mutable, c’est bien des formes d’évaluations parresseuses dont il était question. J’invite d’ailleur les lecteurs que ça intrigue à consulter la page suivante : http://www.rfc1149.net/inf355/2009/07/03/evaluation-paresseuse/
Maxime Gaudin.
« volatile » et « thread » dans la même phrase ? *Brrr* dit comme ça, on pourrait croire que cela sert à quelque chose dans ce cas.
Accessoirement, ce mot clé est également un parasite ce qui a abouti à un article d’Andrei Alexandrescu au sujet de ce détournement.
Pour mutable, tout part du fait que l’immuabilité doit avant tout être sémantique, or const est un artéfact syntaxique qui est contrebalancé par mutable. Et il manquerait des exemples pertinents, et j’avoue que les seuls que je recroise régulièrement sont les classes proxy qui procèderaient à des read/fetch paresseux (c’est ça que tu entends par mémoire cache ?), ou des mutex.
C’est vrai, autant pour moi ! C’est d’ailleur avec mutable le mots clefs le plus utilisé des mots clefs poilus !
Oui, mais tu l’as mis dans la case des mot-clés très peu utilisés, alors que ça n’est pas le cas.
C’est plus ou moins ce que j’ai dit non ?
Je corrigerais juste une petite chose : explicit est (relativement) pas mal utilisé, une fois que l’on passe un certain seuil. C’est une règle que l’on trouve dans des livres tels que les Exceptional C++ de Sutter et Effective C++ de Meyers, si je ne m’abuse. Donc dès que l’on atteint un niveau intermédiaire, environ, on s’en sert, on se demande systématiquement si, quand on a un constructeur à un argument, on veut autoriser une conversion implicite.