Depuis que le langage de programmation C++ a été formellement standardisé en 1998, on aurait pu penser que celui-ci ne changerait plus. Mais c'est tout le contraire, puisque l'ISO (International Organization for Standardization) travaille sur la prochaine évolution du langage, officiellement connue sous la dénomination C++0x (le standard actuel étant appelé C++98).

Bien que l'ISO n'en prévoit pas la publication avant 2009, certains compilateurs comme GCC commencent déjà à implémenter les nouvelles fonctionnalités offertes par le C++0x. La suite de cet article décrit les nouvelles fonctionnalités C++0x qui seront supportées par la version 4.3 de GCC et donne une idée de ce que pourrait être le prochain standard C++.

Bonne lecture :).

Le C++0x contient plusieurs additions et changements qui touchent directement le langage en lui-même et demandent des modifications du compilateur C++.

Static Assertions
Actuellement, en C et C++, la macro assert() permet d'évaluer si une condition est remplie au moment de l'exécution. Le C++0x rajoute la déclaration static_assert() qui permet de vérifier si une condition est remplie à la compilation.

static_assert(sizeof(long) >= 8, "64-bit platform is not supported.");

C99 Preprocessor
Le C++0x vise à remettre le préprocesseur C++ au même niveau que le préprocesseur du dernier standard C (C99). Ce dernier permet par exemple de définir des macros prenant un nombre variable d'arguments.

Right Angle Brackets
Pour des raisons d'analyse syntaxique, le C++98 ne permet pas de définir deux > consécutifs en tant que deux symboles séparés. Le C++0x corrige ce petit désagrément syntaxique.

typedef vector<list<int > Table; // OK
typedef vector<list<int>> Flags; // Erreur en C++98, OK en C++0x

Default Template Arguments for Function Templates
En C++98, il est possible de donner un type de données par défaut à une classe générique. Par contre, il n'est pas possible de faire de même avec les fonctions génériques. Le C++0x propose d'enlever cette limitation.

template <class T, class U = double>
void fonction(T t = 0, U u = 0);

Variadic Templates
Les variadic templates sont des fonctions ou des classes génériques acceptant un nombre variable d'arguments de n'importe quel type, chose impossible en C++98.

template <class... Values> class tuple;
tuple<bool, int, string> triplet;

RValue References
Le C++98 définit deux types de références: les pointeurs (ex : int * b = &a;) et les références lvalue (ex : int & b = a;). Le C++0x introduit le concept de référence rvalue, c'est-à-dire des références vers des objets temporaires. Les trois buts de ce nouveau type de référence sont les suivants.

• Eliminer les copies coûteuses et inutiles d'objets quand cela est possible (déplacement d'objets).
  
  
• Simplifier l'utilisation et le passage d'objets temporaires en tant qu'arguments en programmation générique.
  
  
• Donner la possibilité d'avoir des références non-constantes vers des objets temporaires.

Le comité de standardisation essaie de limiter un maximum les changements au niveau du langage, et préfère apporter les nouvelles fonctionnalités en étendant la standard library. Cette approche a l'avantage de minimiser les modifications à apporter aux compilateurs C++ et de minimiser les risques d'incompatibilités avec les programmes C++ existants. Le C++0x contient donc un certain nombre de nouveaux headers.

Header <array>
Ce header offre la possibilité de définir des tables à dimension fixe avec une interface compatible avec les containeurs standards C++.

int TableA[32];
std::array<int, 32> TableB;

std::sort(TableA, TableA + 32);
std::sort(TableA.begin(), TableA.end()); // ERREUR
std::sort(TableB.begin(), TableB.end()); // OK

Header <random>
Ce header définit plusieurs générateurs de nombres aléatoires avec des garanties plus fortes que la fonction C rand(). Cette dernière fonction est souvent mal implémentée et donne de très mauvais résultats avec des algorithmes dépendants de la qualité de la suite de nombres aléatoires générée. Il définit également plusieurs types de distributions (ex : uniforme, normale, exponentielle, de Poisson, etc).

Header <regex>
Ce header offre plusieurs classes qui supportent des fameuses Regular Expressions. Les regex permettent de définir des règles de recherche de chaînes de caractères.

Header <type_traits>
En programmation générique, il est parfois utile de pouvoir déduire certaines informations sur le type de données utilisé. Le header <type_traits> définit toute une suite d'outils permettant d'extraire des informations utiles d'un type de données (ex : s'agit-il d'un pointeur ? d'un entier ? d'un nombre réel ? si c'est un pointeur, vers quel type pointe-t-il ? etc).

Headers <unordered_map> and <unordered_set>
Ces deux headers donnent la possibilité d'utiliser des tables de hachage. Les tables de hachage permettent de faire des recherches d'éléments plus rapidement qu'avec les tables de recherche classiques (O(1) au lieu de O(log n)).

Headers C99
Le C++0x inclut toute une série de headers permettant la compatibilité avec les nouveaux headers définis en C99. Cela offre, par exemple, le support des entiers à taille fixe (ex : int32_t définit un entier signé de 32 bits).

Sources et liens utiles :

• Status of Experimental C++0x Support in GCC 4.3
  http://gcc.gnu.org/gcc-4.3/cxx0x_status.html
  
  
• The C++ Standards Committee
  http://www.open-std.org/jtc1/sc22/wg21/