C++11 représente l’un des tournants les plus importants dans la modernisation du langage C++. Cette version apporte de nombreuses fonctionnalités modernes qui facilitent la gestion de la mémoire, améliorent les performances et permettent d’écrire un code plus clair et plus sûr. Dans cet article, nous présentons les nouveautés essentielles de C++11 avec des exemples pratiques.


1) Le mot-clé auto

Le mot-clé auto permet au compilateur de déduire automatiquement le type d’une variable à partir de l’expression qui lui est assignée. Cela améliore la lisibilité du code et réduit les répétitions inutiles.


auto x = 10;            // int
auto pi = 3.14;         // double
auto name = "Pierre";   // const char*

2) La boucle for basée sur les plages (range-based for)

Introduite en C++11, cette boucle permet de parcourir un conteneur de manière simple et sécurisée.


vector<int> valeurs = {1, 2, 3};

for (auto v : valeurs) {
    cout << v << endl;
}

3) nullptr

nullptr est un littéral de pointeur nul sûr et typé, destiné à remplacer le traditionnel NULL.


int* p = nullptr;

4) Les expressions lambda

Les lambdas permettent de définir des fonctions courtes et anonymes directement à l’endroit où elles sont utilisées.


auto greet = [](const string& name) {
    cout << "Bonjour, " << name;
};

greet("Camille");

5) Les Smart Pointers (unique_ptr, shared_ptr, weak_ptr)

Les smart pointers constituent l’une des innovations les plus importantes de C++11. Ils gèrent automatiquement la mémoire et réduisent les risques de fuites.

unique_ptr


#include <memory>

unique_ptr<int> p = make_unique<int>(42);

shared_ptr


shared_ptr<string> s1 = make_shared<string>("Jacques");
shared_ptr<string> s2 = s1; // le compteur de références augmente

weak_ptr


weak_ptr<string> wp = s1; // évite les références cycliques

6) Move semantics (&&)

Les move semantics permettent de transférer des ressources plutôt que de les copier, ce qui améliore considérablement les performances, notamment avec les objets temporaires.


string a = "Bonjour le monde";
string b = std::move(a); // déplacement au lieu de copie

7) constexpr

constexpr permet d’évaluer certaines expressions à la compilation, offrant ainsi de meilleures performances à l’exécution.


constexpr int carre(int x) {
    return x * x;
}

int y = carre(7);

8) std::array

Une alternative plus sûre et compatible STL aux tableaux C classiques de taille fixe.


#include <array>

array<int, 3> arr = {10, 20, 30};

9) enum class

Les énumérations fortement typées évitent les conflits de noms et apportent davantage de sécurité.


enum class Statut { EnLigne, HorsLigne, Occupe };

Statut etat = Statut::EnLigne;

10) Initializer Lists

Permettent une initialisation plus simple et plus lisible des conteneurs et objets.


vector<string> noms = {"Pierre", "Camille", "Jacques"};

11) static_assert

Effectue des vérifications au moment de la compilation, permettant de détecter des erreurs très tôt.


static_assert(sizeof(long) >= 8, "long doit faire au moins 8 octets");

12) std::tuple

Permet de stocker plusieurs valeurs de types différents dans une seule structure.


auto personne = make_tuple("Pierre", 28, 1.80);

13) Conclusion

C++11 a introduit des fonctionnalités fondamentales qui définissent aujourd’hui le C++ moderne. Les améliorations en matière de performance, de sécurité mémoire et de lisibilité du code continuent d’influencer les standards C++ suivants.

14) TL;DR

  • auto → déduction automatique du type
  • range-based for → itération simplifiée
  • nullptr → pointeur nul plus sûr
  • lambda → fonctions anonymes en ligne
  • smart pointers → gestion mémoire sécurisée
  • move semantics → transferts rapides et efficaces
  • constexpr → évaluation à la compilation
  • std::array, enum class, tuple → structures modernes
  • Compatible avec Visual Studio 2022 et GCC