Cette classe très simple permet d’enregistrer les informations d’un adhérent,
Supposons maintenant que je maintienne un tableau en mémoire de mes adhérents et que je veuille le trier par l’âge de l’adhérent.
Je vais « naturellement » utiliser la classe vector et un foncteur pour trier mon vector.
Le code ressemblera donc à ceci :

L’utilisation plus loin dans le code donnera ceci:

Les foncteurs sont un moyen très puissant pour personnaliser les algorithmes standard de la STL, malheureusement leur définition est peu pratique car elle nécessite d’écrire une classe entière comme SortAdherentAge dans mon exemple.
Le second défaut est que cette classe n’est pas définit à l’emplacement dans le code source où on va l’utiliser, ce qui rend leur utilisation plus difficile.
C’est là qu’intervient les expressions lambda qui vont gommer tous ces défauts.
 

Reprenons maintenant le même exemple :

L’expression lambda débute avec l’écriture de “[]”, la déclaration des paramètres ad1 et ad2 fournissent au compilateur les paramètres de la pseudo-fonction anonyme.
Le type de retour de la fonction est précisé par « ->bool », le corps de la fonction est exprimé entre les deux accolades.
Avec les expressions lambda parcourir le tableau et réaliser un traitement « inline » devient beaucoup plus facile :

Consultez MSDN pour plus de renseignements sur les syntaxes possibles.

L’expression la plus simple :

J’ai spécifié que le type de retour était un long grâce à la syntaxe -> type
Bien entendu cet exemple comme celui qui va suivre est franchement improbable dans notre codage de tous les jours.

Cette fois-ci le retour est spécifié par l’évaluation de l’expression contenue dans decltype.
Alors franchement à quoi cela peut il servir ?
Cette syntaxe peut avoir son utilité avec l’utilisation des modèles (template).
Par exemple avec cette fonction template que j’écris initialement comme suit :

Cette fonction se propose d’additionner deux types de données, pour spécifier le retour de ma fonction j’ai spécifié de manière arbitraire le type Arg2 ce qui réduit fortement les possibilités d’utilisation de ma fonction.

Si je reprends mon exemple sur les rvalues avec la classe XDate et que je veuille écrire ce genre de chose :

cet exemple ne passera pas à la compilation.

Celui-ci par contre fonctionne très bien, auto me permet de rester neutre sur le retour qui sera évalué par decltype.
Pour être complet dans mon exemple j’ai du rajouté l’opérateur + dans ma classe XDate pour que l’exemple compile.

Dans cet exemple on voit la puissance du mécanisme puisque l’expression spécifiée dans decltype à permis au compilateur de déterminer le retour puisque l’opérateur + de XDate était disponible.

L’exemple suivant fonctionne aussi sans avertissement de conversion :

auto v=AddItem(10.,1);

J’additionne un double et un entier.

Pour finir j’ai constaté que dans cet exemple IntelliSense ne savait pas trop comment s’en sortir avec cette utilisation.

Déclare la variable var comme étant un entier, le compilateur connait le type de donnée n et remplacera l’expression par :

int var ;

Par rapport à auto que nous avons vu dans le billet précédent, on peut se poser la question de l’intérêt de decltype, en fait celui-ci vient en complément de auto.
Considérons le cas suivant :

auto d=func() ;

Je viens de déclarer une variable d en accord avec le retour de func() .
Maintenant si je veux déclarer une autre variable du même type que d, je ne veux pas ou ne peut pas forcement appeler la même fonction pour déclarer ma variable.
Dans ce cas l’utilisation de delctype résout le problème :

Je peux aussi écrire :

decltype(func()) dd ;

Car à la différence de auto decltype n’exécute pas l’expression il analyse le type de donnée de l’expression.
Comme précédemment avec auto, IntelliSense est capable de nous donner l’information sur le type de donnée de la variable ainsi déclarée.

Référence MSDN

Pour bien comprendre ce qui va suivre il est impératif de connaitre les méthodes de transmission d’un argument dans une méthode en l’occurrence le passage par valeur et par référence.

Dans la littérature C++, rValue désigne un objet pouvant figurer à droite (right) d’une affectation, alors que lValue désigne un objet pouvant se trouver à gauche.
Concrètement une nouvelle forme de déclaration utilisant l’opérateur && va nous permettre de transférer la responsabilité d’une ressource d’un objet temporaire à un autre, évitant ainsi une libération mémoire et une nouvelle allocation et la copie de la ressource concernée.

Voici une petite classe d’exemple qui illustre le sujet :

XDate alloue en mémoire une chaine de caractère pour tenir une date.
Dans l’appel réalisé dans le main on retrouve bien la séquence décrite précédemment ou un objet temporaire fournit par GetCurrentDay() sert affecter un objet de la même classe dans la méthode SetDate.
Le nouvel opérateur && va nous permettre de faire l’économie d’une libération, allocation et d’un transfert mémoire :
Je vais modifier pour l’exemple la fonction SetDate comme suit :

Dans SetDate je récupère directement l’adresse contenue par le pointeur de l’objet temporaire et je positionne à nullptr celui de l’objet temporaire.
La méthode SetDate modifiée a été appelée parce que nous bien en présence d’un objet temporaire fournit par GetCurrentDay().
Si je modifie comme suit la fonction main() :

J’obtiens l’erreur:

Note: IntelliSense m’avait déjà prévenu de l’erreur avant la compilation …
Si on veut avoir un code opérationnel dans les deux cas, il faudra laisser l’autre méthode SetDate active :

Si on veut forcer la main au compilateur pour utiliser la méthode avec la déclaration rValue on pourra utiliser un static_cast :

Autre exemple :

le premier SetDate reçoit une variable locale (lValue) et donc appellera la version const de SetDate.
le deuxiéme appel est réalisé avec un objet temporaire car référencé nul part dans le programme, c’est donc bien un rValue qui appellera la version XDate && de SetDate.

Bien, maintenant que nous avons compris comment tirer parti de cette fonctionnalité, il reste à implémenter ce mécanisme directement dans notre classe en ajoutant un constructeur de déplacement (Move constructor ) et l’opérateur d’affectation (Move assignement) ainsi qu’un opérateur +.
La classe finale :

Et l’utilisation :

la première ligne utilise le constructeur de copie normal et pas le constructeur de déplacement comme on pourrait s’y attendre (ce qui ressemble bien à un bug (?)).
La seconde ligne va utiliser successivement l’opérateur +, le constructeur de déplacement et enfin l’opérateur d’affectation de déplacement.

Voila pour ce billet un peu long qui j’espère vous a éclairé sur l’utilisation de la référence R-Value.
Référence MSDN

auto permet de déclarer une variable sans spécifier son type de donnée.
Un exemple très simple :

auto myvar= 1 ;

La ligne ci-dessus déclare un variable sans préciser son type.
Celui-ci est déterminé par le compilateur en examinant la partie droite de l’expression.
Le code est alors transformé en :

int myvar= 1 ;

Donc s’il n’y a pas d’affectation le compilateur ne peut pas déterminer le type et retournera donc une erreur.
Le point important qu’il faut retenir c’est que le type de donnée est déterminé à la compilation et non à l’exécution du code.
Dans mon article sur Visual studio 2010 j’avais évoqué les améliorations d’IntelliSense, dans le contexte présent celui-ci nous fournit directement le type de donnée qui sera associée à la variable, il suffit de survoler la souris sur le nom de la variable.

On pourra donc déclarer toutes sortes de variable : des pointeurs, des tableaux de pointeur des constantes, tout cela est possible à partir du moment ou le compilateur peut déterminer le type associé dans la déclaration.

Etc ..
Ce qui ne peut est géré :
L’utilisation d’auto pour le retour d’une fonction :

auto getval();

L’utilisation d’auto pour l’argument d’une fonction
int getval(auto n) ;

La déclaration d’une variable avec auto dans la déclaration d’une classe ou d’une structure.
Les déclarations multiples sur une ligne qui donnent lieu à des types différents :

auto n=1,d=1.0 ,l=1L ;

Après ce tour d’horizon des fonctionnalités basiques de ce mot clef, examinons maintenant ce pour quoi il va être vraiment utile.
Vous avez certainement tous utilisé les conteneurs de la STL (j’espère !) , en voici un exemple tiré de mes codes :

auto va me permettre de me libérer de la syntaxe lourde de l’itérateur (qui est ici très simple):

C’est plus agréable à écrire non ?
Si j’ai besoin d’un const_iterator , la classe vector y pourvoit :

le couple begin() end() laisse la place à cbegin() cend().
Mon exemple était volontairement simple, mais je pense que tout le monde appréciera la simplicité retrouvée pour déclarer un itérateur sur un objet conteneur.

Référence MSDN

Nullptr, littéralement : pointeur nul, devient un mot clef du langage à part entière, il est destiné à remplacer dans votre code NULL qui est une définition:

 #define NULL    0

Nous pouvons maintenant écrire :

Jusqu’à présent rien de bien essentiel par rapport à l’utilisation de NULL.
En fait ce mot clef va s’avérer utile dans le cas suivant :

nullptr permet ici d’éviter la mauvaise résolution d’appel de la méthode suggérée par NULL qui est un entier.

Dernier point : Je n’ai pas fait l’essai, mais il serait intéressant de voir si nullptr peut être utilisé dans du code mixte C++ et C++CLI qui utilise aussi ce mot clef…

static_assert permet de vérifier une condition au moment de la compilation.
Sa syntaxe est la suivante :

static_assert( expression, message)

Exemple :

static_assert( 0==1, "zero n’est pas egal a 1 !") ;

si la condition est vérifiée le compilateur ne dit rien, par contre en cas d’erreur comme dans l’exemple ci-dessus il génère une erreur C2338 avec le message mentionné :
error C2338: zero n’est pas egal a 1 !

Le message ne supporte que les caractères de base et donc pas les accents.
Dans le cas d’utilisation de static_assert avec une classe template, la condition sera vérifiée lorsque une classe utilisant le template sera déclarée.

Référence MSDN

1) Meilleur performance sur des projets volumineux :

L’IntelliSense le compagnon indispensable du développeur s’appuie maintenant sur un mini base SQL et réduit notablement le temps de construction de la base de référence.
On dispose maintenant d’un soulignement des erreurs de syntaxe.

2) Support de Windows 7 dans les MFC

Le ruban (ribbon) peut être construit directement dans l’éditeur de ressources
support du redémarrage de l’application après un crash
le support du « higth DPI »
la prévisualisation des documents associés à l’application dans l’explorateur, ainsi que la vue simplifiée.
La possibilité de ces documents d’être intégrés dans le système de recherche.
Le support du multi-touch
le retour de classwizard.

3) nouvelle bibliothèque sur le parallélisme : (parallel Patterns library)

4) support amélioré sur les principales fonctionnalités que propose le C++0X.

Je reviendrai bientôt dans un article (presque finit !) sur ces différents thèmes.