Ça fait maintenant un bon bout de temps que je n’ai pas posté sur ce blog et c’est notamment à cause de mes études qui me prennent de plus en plus de temps ainsi que mes voyages.

Cependant, j’ai retrouvé la motivation d’écrire mais plus ici. J’ai décider d’héberger moi même mon blog sur mon serveur : blog.mgaudin-online.com

Les sujets sont les mêmes : Linux, Vim, le C++, le LaTeX et en ajoutant mes concours (ACM ICPC notamment).

J’espère que ce nouveau format vous plaira !

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 :

Cependant, certaines situations sont très génantes tel que :

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 :

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 :

Une différence de l’ordre de 340% de rapidité en plus !
Pour un code du type :

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

Wikiversity Mots Clefs C++

MSDN

La langage C++
Auteur:Bjarne Stroustrup
Editeur : Pearson Education; Édition : 2nd Revised edition (16 juin 2004)
ISBN-10: 2744070033
ISBN-13: 978-2744070037

Au long de vos divagations programmistiques vous avez certainement dû apercevoir du code qui resemblait à ça :
for(int i = 0; i < 1000; ++i);

Mais quelle est donc la différence entre i++ et ++i? C’est ce que nous allons essayer de décrouvrir au long de cet article avec un petit bonus final…

Une version PDF de mon article est disponible ici si vous le souhaitez. (Petit soucie de provider, le PDF sera dispo directement la semaine prochaine…)

Une question d’objet temporaire

Tout d’abord, il faut considérer ces incrémentations dans la cadre d’une expression composée. Par exemple :

Quelle est la différence entre ++i et i++ ?

* i++ : Appelée post-incrémentation, l’expression envoie la valeur de i à la fonction, puis incrémente sa valeur de 1. Dans le cadre de notre exemple :
– tableau[0] vaudra 0.
– i vaudra 1 après l’affectation.

* ++i : Appelée pré-incrementation, l’expression incrémente de 1 la valeur de i puis envoie sa nouvelle valeur à la fonction. Dans notre exemple:
– tableau[1] vaudra 0.
– i vaudra 1.

Il y a donc une différence énorme de signification dans les deux écritures et il faudra faire attention au comportement de notre porgramme lorsqu’on manie ce genre d’expressions.
Quel est la différence entre ++i et i++ dans une expression simple ?

Dans un code du type :

Les deux expressions ont exactement le même comportement et ne font qu’incrémenter la valeur de i de 1.

Pourquoi vaut-il mieux utiliser la pré-incrémentation que la post-incrémentation ?

C’est simplement une question de rapidité. En effet, la post-incrémentation va créer une variable temporaire pour s’exécuter ce que ne fera pas le pré-incrémentation. Qui dit variable temporaire, dit accès mémoire et donc perte de temps et de place.
Voici les équivalences :

et

Tout ça pour ça ?

Une variable temporaire, c’est pas grande chose, mais rappelez vous de la boucle for : l’incrémentation est appelée à chaque itération ce qui, à terme peut ralentir l’exécution du programme.
Il faut tout de même savoir que la plupart du temps, le compilateur optimisera. Il y a cependant des cas o`u le compilateur ne saura pas si pré-incrémenter ne changera pas le comportement et ne fera donc rien alors qu’une optimisation aurait dûe être faite.
Comme précisé par Matthieu Brucher, le compilateur aura surtout du mal à optimiser dans le cas d’objets plus complexes et notamment des itérateurs (Cf STL).
D’après les tests effectué d’après l’observation de spiceguid, la pré-décrémentation est plus lente (encore que…) que la pré-incrémentation :

avec un code du type :

Vous êtes prévenus maintenant !

Bonus : Surchage des opérateurs

Vous êtes vous déjà demandé comment faire la différence entre une post-opération et une pré-opération lorsqu’il faut surcharger l’opérateur unaire d’incrémentation (++ ou – -) ? Parce qu’à priori, le code est du genre :

Il y a une astuce ! En effet, pour surcharger une post-opération, il faut ajouter un paramètre inutile ! D’o‘u :

Conclusion

J’espère que ce premier article vous a plu et qu’il vous incitera à revenir régulièrement !

Références

C++ Cookbook
By Jeff Cogswell, Christopher Diggins, Ryan Stephens, Jonathan Turkanis
Publisher: O’Reilly
Pub Date: November 2005
ISBN: 0-596-00761-2

C++ Coding Standards: 101 Rules, Guidelines, and Best Practices
By Herb Sutter, Andrei Alexandrescu
Publisher: Addison Wesley Professional
Pub Date: October 25, 2004
ISBN: 0-321-11358-6

Et surêment plein d’autres…

Merci à Jey et à Paulo pour la relecture.\\
Merci aussi à Matthieu Brucher et spiceguid pour leurs observations très contructives.

Avant de réattaquer avec un peu de code poilu, je vous propose de découvrir un plugin génial pour les fidèles utilisateurs de viM dont je fait partie : Le plugin Codepad.
Pour information, Codepad est un site web où il est possible d’écrire un code source C++ que d’autres utilisateurs pourront visualiser. En plus de ça, il est possible de compiler et d’executer ce code !
Mélangez ça à viM et vous obtenez l’IDE pour mini-projet le plus rapide du monde !

Voici le lien pour obtenir le plugin.

Je suppose que la majorité des utilisateurs de vim savent installer un plugin mais pour être sûr : il suffit de copier le fichier *.vim dans le répertoire plugin de votre installation vim (chez moi : /usr/share/vim/vim72/plugin/ ).

Bon code à tous !

Le but de ce blog sera principalement de vous présenter du code « poilu » en C++, i.e. qui résout un problème de manière élégante et souvent assez technique pour le plaisir de faire du beau. Certains ne comprendrons sûrement pas l’intérêt de tels codes (et on peut comprendre) mais je suis sûr que d’autres apprécieront.

Je profiterai aussi de ce blog pour vous faire part des différents livres que j’ai l’occasion de lire sur le sujet.

Mon côté chercheur se fera aussi un plaisir de vous présenter des articles, des cours et des tutoriaux sur lesquel je travaille.

En espérant que tout cela vous plaira autant qu’à moi !

Maxime Gaudin.

S’il n’y avait qu’un seul site de code poilu, ça serait certainement lui. Ce site nous offre chaque semaine un code, souvent simple, mais qui est source d’erreurs ou d’idées reçues très fréquentes. Il permet ainsi une compréhension approfondie du langage C++ et évite pas mal d’erreurs.

Un exemple très parlant : Combien d’objet(s) temporaire(s) dans cette simple ligne de code ?
string FindAddr( list<Employee> l, string name )

Réponse : 3 ! ( Article 2 )

Et pour couronner le tout, en plus de mettre en évidence des erreurs fréquentes, les auteurs expliquent comment venir à bout de ces problèmes de manière élégante et efficace !

Pour les futurs fans, deux livres ont été écrit en partant des sujets de GoTW :
– « Exceptional C++ » (In-Depth series – Bjarne Stroustrup)
– « More Exceptional C++ » (In-Depth series – Bjarne Stroustrup)

Je ne peux que vous conseillez d’étudier assez finements ces exemples et encore plus ces livres, même si j’en traiterai assez régulièrement sur ce blog.

Pour les non-anglophones, passez votre chemin.

Maxime Gaudin