Nouveautés C++11 | Blog de développement de jeux vidéo

Intro :

Des changements ont été ajoutés dans la nouvelle version du C++ (nommée C++11).

Tous les mots-clés en liaison avec les changements sont représentés dans l’image de l’en-tête.

Explications :

Le mot-clé / constante nullptr :

– Il remplace l’ancien « #define NULL 0 » pour définir un pointeur nul.

Le mot-clé auto :

– Il identifie automatiquement le type de la variable correspondante en fonction de l’affectation décrite. Il permet de simplifier l’écriture du code.

Exemple :

for(auto i = nombres.begin() ; i != nombres.end() ; ++i)
{
&#xA0;&#xA0;&#xA0; std::cout &#x3C;&#x3C; (*i) &#x3C;&#x3C; std::endl;
}

for(auto i = nombres.begin() ; i != nombres.end() ; ++i)

{

    std::cout << (*i) << std::endl;

}

decltype :

– Permet de retrouver le type de l’objet lorsque l’on a utilisé le mot-clé auto.

Variadic templates :

– Permet d’utiliser un nombre variable de spécifications de classe sur les templates.

unique_ptr<> :

– Un pointeur intelligent possédant qu’un seul (et unique) propriétaire !

Initialisation des données membres non-statique :

– Les variables membres non-statiques peuvent être définit au sein même de la déclaration de la classe.

class UneClasse
{
public:
    UneClasse() {}
 
    int a = 7;
    int b = 5;
 
private:
    std::string s{"Une chaîne"};
};

class UneClasse

{

public:

UneClasse() {}

int a = 7;

int b = 5;

private:

std::string s{"Une chaîne"};

};

Alias de templates :

– On peut désormais utiliser le mot-clé « using » pour faire un alias à la place du classique typedef

Constructeurs délégués :

– Avec le C++11, un constructeur peut appeler un autre constructeur directement.

struct A
{
    A(int);
    A(): A(42) { } // délègue au constructeur A(int)
};

struct A

{

A(int);

A(): A(42) { } // délègue au constructeur A(int)

};

Range-based for :

– On peut parcourir un tableau, une liste, un vector, etc… avec une boucle simplifiée :

std::vector<double> v;

for (double d : v)
{
    std::cout << d << std::endl;
}

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

for (auto& d : v)
{
    ++d;
}

for (auto const& d : v)
{
    ++d;
}

std::map<int, std::string> m;

for (auto element : m)
{
    printf("%d\n", element.first);
    printf("%s\n", element.second);
}

std::vector<double> v;

for (double d : v)

{

std::cout << d << std::endl;

}

for (auto d : v)

{

std::cout << d << std::endl;

}

for (auto& d : v)

{

++d;

}

for (auto const& d : v)

{

++d;

}

std::map<int, std::string> m;

for (auto element : m)

{

printf("%d\n", element.first);

printf("%s\n", element.second);

}

Les fonctions lambda :

– La syntaxe est : [ liste de capture ] ( paramètres ) retour { code }

Exemple :

[](int element) {
&nbsp;&nbsp;&nbsp; cout &lt;&lt; element &lt;&lt; endl;
}

[](int element) {

    cout << element << endl;

}

On peut passer une fonction anonyme à une variable :

std::function<int (int, int)> addition = [](int x, int y) -> int {
    return x + y;
};

std::function<int (int, int)> addition = [](int x, int y) -> int {

return x + y;

};

Les énumérations fortement typées :

Dorénavant les numérations peuvent être fortement typées ainsi :

// On rajoute le mot-cl&eacute; &quot;class&quot;
enum class Direction { Haut, Droite, Bas, Gauche }; // Se comporte comme des attributs !

//&nbsp; On est oblig&eacute; de sp&eacute;cifier la classe d&apos;origine &quot;Direction::&quot;
Direction direction = Direction::Haut;

// Pour afficher sa valeur enti&egrave;re on doit convertir :
std::cout &lt;&lt; static_cast&lt;int&gt;(direction) &lt;&lt; std::endl;

// On rajoute le mot-clé "class"

enum class Direction { Haut, Droite, Bas, Gauche }; // Se comporte comme des attributs !

//  On est obligé de spécifier la classe d'origine "Direction::"

Direction direction = Direction::Haut;

// Pour afficher sa valeur entière on doit convertir :

std::cout << static_cast<int>(direction) << std::endl;

Bug template corrigé :

// Avant :
std::vector<std::vector<int> > nombres;

// Après :
std::vector<std::vector<int>> nombres;

// Avant :

std::vector<std::vector<int> > nombres;

// Après :

std::vector<std::vector<int>> nombres;

Les listes d’initialisateurs :

std::vector<int> nombres = { 1, 2, 3, 4, 5 };
std::map<int, std::string> nombres = { { 1, "un" }, { 2, "deux" }, { 3, "trois" } };

1 2	std::vector<int> nombres = { 1, 2, 3, 4, 5 }; std::map<int, std::string> nombres = { { 1, "un" }, { 2, "deux" }, { 3, "trois" } };

Les tableaux à taille fixe :

std::array<int, 5> tableauFixe;

1	std::array<int, 5> tableauFixe;

Tuple :

Mémoire locale pour un thread :

– Avec le mot-clé std::thread_local, on peut spécifier une variable locale à un thread !

Sizeof sur les attributs de classes :

– On peut désormais savoir la taille qu’occupe un attribut d’une classe.

Références :

– http://cpp.developpez.com/redaction/data/pages/users/gbdivers/cpp11/

– http://fr.wikipedia.org/wiki/C%2B%2B11

– http://openclassrooms.com/courses/introduction-a-c-2011-c-0x