Autour de Linux

Le 12 août 2011, Herb Sutter annonçait sur son blog que la nouvelle norme C++0x était approuvée à l’unanimité. La précédente norme datait de 1998 et avait juste subi une mise à jour en 2003.

Le compilateur gcc inclus dans Linux a commencé à implémenter les nouveautés de cette (future) nouvelle norme depuis la version 4.3. Notez que Ubuntu 11.04 dispose de la version 4.5 de gcc et que dans Ubuntu 11.10 à venir, la version de gcc sera la 4.6. Il faudra attendre les versions 4.7 et suivantes pour que toutes les extensions au langage permises par la nouvelle norme apparaissent dans gcc.

Pour pouvoir compiler un programme avec gcc en utilisant la nouvelle norme, il faut ajouter une option sur la ligne de commande de g++: -std=c++0x

$ g++ -Wall -std=c++0x -c mon_fichier.cpp

Je ne vais pas détailler toutes les nouveautés de cette norme. D’autres le font bien mieux que moi mais je voudrais juste en présenter quelques unes qui me semblent intéressantes pour montrer l’évolution du langage.

C++0x introduit les types char16_t et char_32_t non-signés définis dans le fichier d’entête cstdint. Ces nouveaux types seront utiles pour les caractères unicode puisqu’avec le type char_t sur 8 bits, on retrouve les trois tailles possibles d’un caractère unicode.

#include <iostream>
#include <cstdint>

int main()
{
  char16_t c = 'a';
  char32_t d = 'b';
  std::cout << sizeof(c) << std::endl;
  std::cout << sizeof(d) << std::endl;   
  
  return 0;
}

L’inférence de type permet au compilateur de déduire le type d’une variable à partir de la façon dont elle est initialisée. Utile dans des boucles ou dans le parcours de listes, de dictionaires…

auto ma_variable = 10;  // ma_variable aura le type int défini au moment de l'initialisaton

Le foreach attendu par certains apparaît aussi dans C++0x. Il permet de parcourir une liste facilement.

#include <iostream>

int main()
{
  int a[5] = {1, 2, 3, 4, 5};
  for(int i : a)
  {
    std::cout<<i<<std::endl;
  }  
  return 0;
}

Le support des fonctions lambdas est aussi une des nouveautés. Les fonctions lambdas sont des fonctions anonymes ne nécessitant pas de définition comme les fonctions habituelles et peuvant être utilisées directement dans le code. Elles sont définies par exemple de cette façon:

[](int i, int y)
{
  if(i > y)return i;
  else return y;
}

Une autre nouveauté très utile lors de cross-compilation est l’apparition des assertions statiques disponibles au moment de la compilation et non plus comme les assertions classiques au moment de l’exécution. Elles permettent de tester les types de variables et de s’assurer, par exemple, qu’ils ont la taille désirée.

static_assert(sizeof(char16_t) == 2, "char16_t doit avoir une taille de 2");

int main()
{
    return 0;
}

Le pointeur nullptr est introduit qui peut prendre n’importe quel type de pointeur ou le type booléen. NULL par contre, est généralement défini comme la valeur entière 0.

Autre point que je voudrais présenter est la possibilité pour un constructeur d’une classe d’appeler un autre constructeur de cette même classe ce qui n’était pas possible auparavant.

#include <iostream>

class C
{
  private:
    int i;
  
  public:
    C(int y){std::cout<<y<<std::endl;}
    C(){C(20);}
};

int main()
{
  C c;
  return 0;
}

Ajoutons aussi que C++0x apporte le support des threads, des tuples, des expressions régulières via une mise à jour de la Standard Template Library et plein d’autres choses qu’il m’est impossible d’expliquer ici tant elles sont nombreuses. Mais on voit clairement que le langage s’est modernisé et introduit des choses qui étaient déjà présentes dans d’autres langages plus récents.

Sources:
C++0x feature support in GCC 4.5 – article sur le site d’IBM
C++0x faq de Bjarne Stroustrup
C++11 – article de Wikipedia
Le draft de la future norme – fichier pdf
C++ Le standard C++0x a enfin été voté – article de linuxfr.org