Un problème, à l’origine
Considérons le code suivant.

Quelle fonction est appellée ? f(int) ou f(char *) ? C’est f(int) qui sera toujours appelée, même si vous vouliez appeler l’autre, en passant donc un pointeur nul.
Comment appeler l’autre alors, lorsque l’on veut passer un pointeur nul ?
Il faut recourir à une conversion explicite.
f( (char*)0 );
Pas très intuitif ni agréable n’est-ce pas ?

On peut se demander si NULL ne résoud pas le problème, maintenant. Hélas non, car sur un compilateur qui respecte la norme, NULL a pour valeur 0… ni (void *)0 ni quoique ce soit d’aute, 0 simplement.
Ce qui entraine donc que :
f(NULL);
appellera f(int) encore une fois.

Il y a d’autres situations qui posent problème : toutes celles où l’on voudrait avoir un objet qui désigne un pointeur nul mais où l’on ne dispose que de la valeur littérale 0.

Beaucoup de suggestions et propositions ont été apportées mais il y a une solution dans la prochaine norme qui règlera ces problèmes : nullptr.

nullptr, la solution
nullptr est un mot-clé réservé du langage qui désigne une rvalue constante de type std::nullptr_t. L’implémentation du type en question est laissée à l’appréciation des compilateurs. On est toutefois sûr d’en disposer sur un compilateur qui implémente(ra) la norme C++0x.

Voici des exemples d’utilisation :

tirés de cet article.

Enfin, notre problème de départ est facilement résolu. Si l’on veut appeler f(char*) en lui donnant un pointeur nul, il nous suffit d’écrire f(nullptr).

Voici donc un nouveau billet sur les nouveautés de C++0x. D’autres devraient suivre petit à petit.

Bonne lecture.

Est-ce que vous vous souvenez de la fonction printf de la bibliothèque standard C ?
Au cas où, je vous rappelle son prototype :
int printf (const char *format, ...);
Vous vous souvenez aussi probablement que les « … » permettent de donner autant d’arguments que l’on souhaite à printf et que l’on appelle cela les ellipses. Les fonctions qui utilisent ceci sont appelées fonctions variadiques.
Avec le C++ actuel, nous pouvons toujours utiliser cette technique.

Seulement, une grande nouveauté va être apportée au C++. Elle reprend l’idée des fonctions variadiques mais pour l’appliquer… aux paramètres d’une fonction ou classe template !

En effet, nous allons en C++0x pouvoir créer des classes et fonctions templates pouvant accepter un nombre arbitraire d’arguments (pour les fonctions) et de paramètres (pour les classes/structures), non fixé à l’avance.

Pour mieux vous présenter comment cela sera fait, je vais d’abord donner quelques définitions.

• template parameter pack : c’est un paramètre template qui accepte zéro ou plus arguments templates. On donne généralement l’exemple suivant.
  template<class ... Types> struct Tuple { };
  Ici class … Types est donc un template parameter pack. Sachez aussi que c’est cette syntaxe qui sera utilisée en C++0x.
• function parameter pack : c’est un paramètre de fonction qui accepte zéro ou plus arguments de fonctions. Un exemple illustrant mes propos ci-dessous.
  template<class ... Types> void f(Types ... args);
  Ici Types … args est un function parameter pack. Ici aussi on est en présence de la syntaxe définitive adoptée pour C++0x.
• On dénote par parameter pack soit un template parameter pack soit un function parameter pack.
• pack expansion : c’est une expression qui permet de donner à une fonction, une liste d’initialisation, etc un ou plusieurs parameter packs. Voici un exemple.
  template<class ... Types> void f(Types ... rest);
  template<class ... Types> void g(Types ... rest) {
  f(&rest ...);
  }

  Ici &rest … est une pack expansion.

Et maintenant, il ne reste plus qu’à présenter la règle qui définit l’utilisation des expansions :

Un parameter pack dont le nom apparaît dans une pack expansion est « étendu » par cette pack expansion. Toutefois, l’expansion ne se fait que par la pack expansion la plus intérieure (par rapport aux parenthèses et chevrons ( < et > ) qui ne doit toutefois pas être plus intérieure que le parameter pack.

Illustration en code.

Tout cela permettra d’écrire un code encore plus générique, notamment pour représenter des n-uplets (au sens mathématique) que l’on dénote généralement par tuples en programmation, ainsi que des classes utilitaires autour des fonctions et foncteurs comme Boost.Bind, Boost.Function, etc. Cette nouvelle possibilité fera donc des heureux dans l’univers de la programmation générique en C++ car elle apporte un plus à un programme de nouveautés autour des templates déjà bien chargé.

Je vous conseille de consulter le site du commité ISO de normalisation du C++ pour obtenir plus de détails sur toutes ces choses.

Ce billet a été écrit en se basant sur la version du 26 Juin 2008 du brouillon de la norme de C++0x et utilise les exemples donnés dans le document en question.

L’évolution du C++ est le centre d’intérêt de la planète entière depuis quelques temps.
(ou presque…)

D’une part, le comité de normalisation du C++ prépare la prochaine version, C++0x, pour 2009 (si la nouvelle version est finalisée en 2009, C++0x deviendra C++09).
D’autre part, ils se penchent également sur la nouvelle bibliothèque standard avec bien plus de choses qu’actuellement. Vous pouvez trouver des informations sur le site du comité : http://www.open-std.org/JTC1/SC22/WG21/ .

Le but est de fournir le plus de facilités au programmeur C++ de manière portable et efficace, en lui mettant à disposition des outils génériques et flexibles.
On retrouve notamment pour la future SL des threads, description de types, des expressions régulières …

Quand à la prochaine version de C++, elle fournira quelques nouveaux mots-clés comme requires ou decltype, entre autres, et fournira la notion de concept, qui va s’avérer pratique pour ceux qui utilisent la programmation générique.

Encore une fois, le meilleur moyen de découvrir tout ça est le site du comité, dont je redonne le lien ici : Comité ISO C++.

Bonne lecture.