Fonctionnalités du C++ moderne prises en charge par les compilateurs C++ améliorés par Clang de RAD Studio

De RAD Studio
Aller à : navigation, rechercher

Remonter à C++ moderne


Remarque: Même si RAD Studio prend en charge C++11 et C++14, vous pouvez rencontrer des problèmes lors de la compilation avec les anciennes chaînes d'outils C++. Nous vous recommandons d'utiliser la chaîne d'outils Windows 64 bits (Moderne).

Sommaire

Fonctionnalités C++17 prises en charge par les compilateurs C++ améliorés par Clang

Les compilateurs améliorés par Clang pour Win32 et Win64 (bcc32c/bcc32x et bcc64/bcc64x) implémentent quasiment tous les standards ISO C++17.

Remarque: Voir Statut de conformité des fonctionnalités du langage C++ moderne pour connaître les fonctionnalités C++17 prises en charge par chaque compilateur C++ de RAD Studio.
Parmi les fonctionnalités intéressantes du C++17 :
  • Constexpr if - pour les expressions ; il est utilisé au moment de la compilation.
  • string_view - accès en lecture seule à une grande variété de types chaînes.
  • If-init (initialisation d'une variable dans une instruction if).
  • Liaisons structurées.
  • Variables inline
Pour de plus amples informations sur C++17 :

Fonctionnalités C++14 prises en charge par les compilateurs C++ améliorés par Clang

Les compilateurs améliorés par Clang pour Win32 et Win64 (bcc32c/bcc32x etbcc64) implémentent quasiment tous les standards ISO C++14.

Remarque: Voir Statut de conformité des fonctionnalités du langage C++ moderne pour connaître les fonctionnalités C++14 prises en charge par chaque compilateur C++ de RAD Studio.
Parmi les fonctionnalités intéressantes du C++14 :

Pour de plus amples informations sur C++14 :

Fonctionnalités C++11 prises en charge par les compilateurs améliorés par Clang

Voici la liste des fonctionnalités C++11 prises en charge par les compilateurs C++ améliorés par Clang de RAD Studio.

Remarque: Voir Statut de conformité des fonctionnalités du langage C++ moderne pour connaître les fonctionnalités C++11 prises en charge par chaque compilateur C++ de RAD Studio.
  • Bcc32c et bcc32x (le compilateur amélioré par Clang pour Win32) implémentent l'ensemble du standard C++11 ISO.
  • Les compilateurs C++ améliorés par Clang plus anciens supportent partiellement les fonctionnalités de C++11 :
    • Les fonctionnalités C++11 de base fonctionnent typiquement avec BCCIOSARM64. Cela inclut les templates variadic, les assertions statiques, le multi-déclarateur auto, les expressions lambda, etc.
    • BCCIOSARM64 ne supporte pas typiquement les fonctionnalités C++11 Standard (Run-time). Cela inclut l'initialisation des objets classe par rvalues, les opérations atomiques, etc.
  • BCC32 supporte également les fonctionnalités C++11 décrites dans Fonctionnalités C++11 - Compilateur classique.
Remarque: Lorsque les mots-clés spécifiques à C++11 comme nullptr, noexcept, etc. sont utilisés (voir http://en.cppreference.com/w/cpp/keyword pour la liste complète), l'EDI de RAD Studio les reconnaît, mais les compilateurs C++ de génération précédente (BCC32) renvoient une erreur de compilation. Veuillez noter que seuls les compilateurs C++ basés sur Clang supportent le standard C++11.

Description des références rvalue

Les références rvalue sont supportées par BCC32 et les compilateurs C++ améliorés par Clang.

Pour de plus amples informations sur cette fonctionnalité, voir Références rvalue.

Références rvalue pour *this

Références rvalue pour *this est une fonctionnalité C++11 conçue pour étendre les avantages de la sémantique de déplacement au paramètre *this implicite.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Rvalue references for *this.

Initialisation des objets de classe par rvalues

Le standard C++11 introduit la capacité d'initialiser les objets de classe par rvalues, afin d'écrire du code clair, concis et efficace. 

Cela signifie que les temporaires sont maintenant initialisés directement depuis l'objet rvalue entier, plutôt que d'appeler un constructeur pour copier l'objet dans le temporaire.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Initialization of class objects by rvalues.

Initialiseurs de membres de données non statiques

C++11 introduit la possibilité d'initialiser des membres de données non statiques au sein de la déclaration de la classe.

Les initialiseurs des membres de données non statiques sont limités à =initializer-clause et {initializer-list}.

Pour de plus amples informations sur cette fonctionnalité, voir l'exemple ci-dessous ou le document de proposition Non-static data member initializers.

Exemple Initialiseurs de membres de données non statiques

#include <string>

struct B {
        B(int, double, double);
};

class A {
        int a = 7; // OK
        std::string str1 = "member"; // OK
        B b = {1, 2, 3.0}; //OK
        std::string str2("member");   // ill-formed
};

Templates variadic

Les templates variadic font référence à des templates de classe ou de fonction qui prennent un nombre variable de paramètres.

Dans ce but, C++11 a introduit les packs de paramètres pour représenter une liste de zéro ou de plusieurs paramètres.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Variadic templates.

Exemple Variadic templates

Voici un petit exemple illustrant la syntaxe C++ des templates variadic.

template<class ... T>
class A {
        // template class body
};

template<char ... T>
class B {
        // template class body
};

A<>a1;
A<int, char>a2;
A < B < 'a' >> a3;

B<>b1;
B < 'a', 'b' > b2;

Extension des paramètres template de modèle variadic

Lors d'expérimentations en situation réelle avec les templates variadic, certaines limitations relatives aux paramètres template de modèle n'ont pas été couvertes.

Le standard C++11 étend les paramètres template de modèle variadic afin de résoudre ce problème.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Extending Variadic Template Template Parameters.

Liste d'initialiseurs

Les listes d'initialiseurs sont une fonctionnalité ayant été étendue dans le standard C++11.

Une liste d'initialiseurs représente une liste d'arguments ordonnés, entre accolades, utilisée pour initialiser les structures, les classes et les tableaux.
Jusqu'au C++11, seules les classes conformes à la définition POD (Plain Old Data) pouvaient être initialisées en utilisant des listes d'initialiseurs. Maintenant, les classes telles que std::vector peuvent aussi être initialisées en utilisant des listes d'initialiseurs. Cela s'effectue en utilisant un template nommé std::initializer_list<> qui peut être transmis comme argument à des constructeurs ou à d'autres fonctions.

Assertions statiques

Les assertions statiques sont supportées par BCC32 et les compilateurs C++ améliorés par Clang.

Pour de plus amples informations sur cette fonctionnalité, voir Assertions statiques (C++11).

Variables auto-typées

Les variables auto-typées sont une fonctionnalité de C++11 qui permet à un programmeur de déclarer une variable de type auto, le type lui-même ayant été déduit de l'expression de l'initialiseur de la variable. Le mot clé auto est traité comme un simple spécificateur de type (qui peut être utilisé avec * et &), et sa sémantique est déduite de l'expression de l'initialiseur.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition du standard C++11 : Auto-typed variables.

Exemples de variables auto-typées

int IntFunc() {}
bool BoolFunc() {}
char* CharSFunc() {}

int _tmain(int argc, _TCHAR* argv[]) {
        // x is int
        auto x = IntFunc();
        // y is const bool
        const auto y = BoolFunc();
        // w is char*
        auto w = CharSFunc();
        return 0;
}

Voici un autre exemple du type auto : Tri de vecteur générique (C++).

Multi-déclarateur auto

Le standard C++11 inclut la forme multi-variable des déclarations auto comme :

int* func(){}

int _tmain(int argc, _TCHAR* argv[])
{
        auto x = 3, * y = func(), z = 4;
        return 0;
}

Les expressions utilisant le multi-déclarateur auto subissent une restriction dans la mesure où les variables doivent avoir le même type de base.

Par exemple, la ligne de code suivante est formée correctement :

auto x = 3, y = new int;

car x et y ont le même type de base  : int, alors que le code suivant :

auto x = 3, y = 3.5;

générera l'erreur :

[bcc64 Error] File1.cpp(11): 'auto' déduit comme 'int' dans la déclaration de 'x' et déduit comme 'double' dans la déclaration de 'y' 

Cette fonctionnalité n'est pas supportée par les compilateurs C++ améliorés par Clang.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition du standard C++11 : Multi-declarator auto

Suppression de auto comme spécificateur de classe de stockage

Le standard C++11 supprime complètement l'utilisation de auto comme spécificateur de classe de stockage. Cette fonctionnalité n'est pas supportée par les compilateurs C++ améliorés par Clang.

Si votre application C++ utilise auto en tant que spécificateur de classe de stockage, les compilateurs C++ améliorés par Clang afficheront l'avertissement suivant :

Modèle:Avertissement

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition du standard C++11 : Removal of auto as a storage-class specifier.

Nouvelle syntaxe de déclarateur de fonction

Cette fonctionnalité C++11 change la sémantique de auto et introduit la syntaxe pour les déclarateurs de fonction. Le spécificateur de type auto signifie que le type d'une variable en cours de déclaration devrait être déduit de l'expression de son initialiseur ou être spécifié explicitement à la fin d'un déclarateur de fonction.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition du standard C++ 11  : Nouvelle syntaxe de déclarateur de fonction

Type déclaré d'une expression

Le type déclaré d'une expression est supporté par BCC32 et les compilateurs C++ améliorés par Clang. 

Pour de plus amples informations sur cette fonctionnalité, voir Spécificateur de type decltype (C++11).

Types de retour incomplets

L'exigence qu'un type d'expression d'appel de fonction soit complet, lorsqu'il est utilisé comme un paramètre decltype n'est pas seulement inutile, mais est aussi risquée.

Dans C++11, lorsque le paramètre d'une expression decltype est une expression d'appel de fonction renvoyant un type de classe, il n'est pas nécessaire que le type soit complet. De la même façon, un objet temporaire n'est pas introduit pour la valeur de retour, ce qui économise de l'espace de stockage et évite d'invoquer le destructeur.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Incomplete return types.

Crochets droits

Dans les compilateurs C++ améliorés par Clang, deux crochets droits consécutifs ne génèrent plus d'erreur et ces constructions sont traitées conformément au standard C++11.

Pour de plus amples informations, voir le document de proposition C++11 Right angle brackets.

Exemple Crochets droits

#pragma hdrstop
#pragma argsused

#include <tchar.h>
#include <stdio.h>

#include <vector>
typedef std::vector<std::vector<int> > Table;  // OK
typedef std::vector<std::vector<bool>> Flags;  // OK

int _tmain(int argc, _TCHAR* argv[]) {

        return 0;
}

Arguments de template par défaut pour les templates de fonctions

L'impossibilité de définir des arguments de template par défaut pour les templates de fonctions a longtemps limité le style de la programmation.

Dans C++11, de tels arguments par défaut peuvent être utilisés.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Default template arguments for function templates.

Exemple Arguments de template par défaut pour les templates de fonctions

template<class T = int, class U = char>
void function() {
        // function body
}

int _tmain(int argc, _TCHAR* argv[]) {
        function<>();            // OK, template arguments are -> int char
        function<int>();         // OK, template arguments are -> char
        function<char, char>();  // OK, template arguments are -> char char
        return 0;
}

Résolution du problème SFINAE pour les expressions

Le standard C++11 résout le problème SFINAE (substitution failure is not an error, l'échec de substitution n'est pas une erreur) pour les expressions. Cela s'effectue en autorisant des expressions totalement générales à la condition que la plupart des erreurs générées par ces expressions soient traitées comme des échecs SFINAE plutôt que comme des erreurs.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Solving the SFINAE problem for expressions.

Templates d'alias

Avec le nombre accru d'utilisations des types paramétrés dans C++, le besoin de recourir à des alias de types paramétrés a augmenté. C++11 ajoute cette fonctionnalité au standard.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Alias templates.

Templates extern

Les templates extern sont supportés par BCC32 et les compilateurs C++ améliorés par Clang.

Pour de plus amples informations sur cette fonctionnalité, voir Templates extern (C++11).

Constante pointeur null

C++11 introduit nullptr, la constante pointeur null, afin de mettre fin à l'ambiguïté entre 0 et un pointeur null.

Bien que la macro NULL existe, elle est insuffisante car on ne peut pas la distinguer d'un entier 0 dans un appel de fonction ayant une surcharge avec un paramètre int et une autre avec un paramètre char*.

En conséquence, nullptr est maintenant un mot réservé. L'entier 0 ne sera pas implicitement converti en n'importe quel type de pointeur. Le pointeur null peut être converti en n'importe quel type de pointeur.
Remarque: Le pointeur null ne peut pas être utilisé dans une expression arithmétique, assigné à une valeur intégrale ni comparé à une valeur intégrale.
Remarque: Pour davantage d'informations, voir le document de proposition Null pointer constant.
Voir nullptr.

Enumérations fortement typées

Les énumérations fortement typées sont supportées par BCC32 et les compilateurs C++ améliorés par Clang.

Pour de plus amples informations sur cette fonctionnalité, voir Enumérations fortement typées (C++11).

Déclaration forward des énumérations

La déclaration forward des énumérations est supportée par BCC32 et les compilateurs C++ améliorés par Clang.

Pour de plus amples informations sur cette fonctionnalité, voir Déclaration forward des énumérations (C++11).

Expressions constantes généralisées

Le standard C++11 généralise la notion d'expressions constantes pour inclure les appels à des fonctions simples (fonctions constexpr) et les objets de types définis par l'utilisateur qui sont construits à partir de simples constructeurs (constructeurs constexpr).

Une fonction est une fonction expression constante si :
  • Elle renvoie une valeur (le type void n'est pas autorisé)
  • Le corps de la fonction est composé d'une seule instruction, l'instruction return : return expr;
  • Elle est déclarée avec le mot clé constexpr.
Une variable ou un membre de données est une valeur expression constante si :
  • Il est déclaré avec le mot clé constexpr
  • Il est initialisé avec une expression constante ou une rvalue construite par un constructeur d'expression constante avec des arguments d'expression constante.
Un constructeur est un constructeur d'expression constante si :
  • Il est déclaré avec le mot clé constexpr
  • La partie initialiseur-membre n'implique que des expressions constantes potentielles
  • Son corps est vide.

Exemple Expressions constantes généralisées

L'exemple suivant contient une fonction constexpr, une variable constexpr et un constructeur constexpr : 

constexpr int add(int x, int y) {
        return x + y;
}
constexpr double var = 2 * add(3, 4);

class A {
        constexpr A(int newA, int newB) : a(newA), b(newB) {
        }

private:
        int a;
        int b;
};

Support de l'alignement

Le standard C++11 a pour objectif d'étendre le langage standard et la bibliothèque grâce à des fonctionnalités relatives à l'alignement.

Ces fonctionnalités d'alignement incluent les éléments suivants :
  • Spécificateur d'alignement (alignas) pour les déclarations
  • Expression alignof pour récupérer les exigences d'alignement d'un type
  • Arithmétique d'alignement par le support de la bibliothèque
  • Fonction standard (std::align) pour l'alignement des pointeurs à l'exécution
Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Alignment support.

Délégation de constructeurs

C++11 introduit la possibilité de déléguer des constructeurs. Cela signifie que les constructeurs de classe peuvent être invoqués au sein d'autres constructeurs de la même classe.

C'est une fonctionnalité très utile qui permet aux programmeurs de réduire la quantité de code écrit tout en ayant du code plus expressif. 

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Delegating constructors.

Exemple Délégation de constructeurs

L'exemple suivant montre comment la délégation de constructeurs peut être utilisée :

class B {
        B(int newA) : a(newA) { /* other initializations */
        }

public:
        B() : B(15) { /* other initializations */
        }

public:
        int a;
};

Opérateurs de conversion explicite

Avec C++11, les fonctions de conversion qualifiées de façon explicite fonctionnent dans le même contexte que les constructeurs qualifiés de façon explicite. Elles produisent également des diagnostics dans le même contexte que les constructeurs. Le but est d'éviter des situations où le compilateur accepte sans problème du code qui n'est pas sémantiquement correct.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Explicit conversion operators.

Nouveaux types de caractères

C++11 introduit de nouveaux types caractère permettant de manipuler les chaînes de caractères Unicode.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Littéraux et types de caractères Unicode (C++11).

Littéraux chaîne Unicode

C++11 introduit de nouveaux types de caractères permettant de manipuler les littéraux chaîne Unicode.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Littéraux et types de caractères Unicode (C++11).

Littéraux chaîne brute

Noms de caractères universels dans les littéraux

Afin que le code C++ soit moins dépendant de la plate-forme, C++11 lève les interdictions relatives aux noms des caractères universels source élémentaires et des caractères de contrôle au sein des littéraux chaîne et caractère. Des interdictions relatives aux valeurs de substitution dans tous les noms de caractères universels ont été ajoutées.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Universal character names in literals.

Littéraux définis par l'utilisateur

C++11 introduit de nouvelles formes de littéraux utilisant des syntaxes et sémantiques modifiées afin de fournir des littéraux définis par l'utilisateur.

En utilisant des littéraux définis par l'utilisateur, les classes définies par l'utilisateur peuvent fournir une nouvelle syntaxe en matière de littéraux.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition User-defined literals.

Types de disposition standard

C++11 sépare les exigences propres aux membres triviaux des exigences de disposition afin de créer une spécification plus propre.

Les types POD (Plain Old Data) sont maintenant définis par deux nouvelles catégories : types triviaux et types de disposition standard.

Dans C++11, les types de disposition standard sont autorisés à avoir des classes de base. Toutefois, les classes de base ne sont pas autorisées à avoir des membres virtuels ou des bases virtuelles. Par ailleurs, les types de disposition standard sont autorisés à avoir un contrôle d'accès. 

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Standard Layout Types.

Fonctions par défaut

Une fonction par défaut est une fonction qui contient =default; dans son prototype. Cette construction indique que la définition par défaut de la fonction devrait être utilisée.

Les fonctions par défaut sont une fonctionnalité spécifique de C++11.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Defaulted functions.

Exemple Fonctions par défaut

class A {
        A() = default;                    // OK
        A& operator = (A & a) = default;  // OK
        void f() = default;               // ill-formed, only special member function may default
};

Fonctions supprimées

Une fonction supprimée est une fonction qui contient =delete; dans son prototype. Cette construction, introduite avec C++11, indique que la fonction ne pourra pas être utilisée.

Cette construction peut être utilisée pour empêcher l'utilisation des possibilités de langage par défaut (comme les constructeurs par défaut ou les opérateurs par défaut) ou les conversions problématiques.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Deleted functions.

Exemple Fonctions supprimées

class A {
        A() = delete;
        A& operator = (A & a) = delete;
};

Déclarations friend étendues

C++11 étend le langage en cours pour supporter une plus grande gamme de déclarations friend.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Extended friend declarations.

Extension de sizeof

C++11 étend la fonctionnalité de sizeof afin que les membres de classe puissent être envoyés comme paramètres même si aucun objet n'a été instancié.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Extending sizeof.

Exemple Extension de sizeof

Le code suivant représente un exemple simple d'utilisation de sizeof.

#pragma hdrstop
#pragma argsused

#include <tchar.h>
#include <stdio.h>

class A {
public:
        int a;
};

int _tmain(int argc, _TCHAR* argv[]) {
        // no object of type A has been instantiated
        int c = sizeof(A::a);
        // well-formed
        return 0;
}

Espaces de nommage inline

Le standard C++11 autorise le mot clé inline dans une namespace-definition (définition d'espace de nommage). Cela est effectué dans le but de spécifier que les membres de l'espace de nommage peuvent être définis et spécialisés comme s'ils appartenaient réellement à l'espace de nommage englobant.

Cette construction est appelée espace de nommage inline et résout le problème où les templates pouvaient uniquement être spécialisés dans leur espace de nommage réel et non dans l'espace de nommage dans lequel ils ont été importés. 

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Inline namespaces.

Unions non restreintes

Le standard C++11 assouplit la restriction relative aux membres des unions. Ainsi, dans les compilateurs C++ améliorés par Clang, tous les types peuvent être des membres d'union, exceptés les types référence.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Unrestricted unions.

Types locaux et non nommés comme arguments de template

Le standard C++11 permet aux utilisateurs d'utiliser les types locaux et non nommés comme des arguments de template.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Local and unnamed types as template arguments.

Boucle for basée sur l'étendue

La boucle basée sur l'étendue est une fonctionnalité introduite par le standard C++11.

Dans les compilateurs C++ basés sur Clang, vous pouvez créer des boucles for qui parcourent une liste ou un tableau sans calculer le début, la fin ni utiliser un itérateur.

L'exemple suivant montre la syntaxe d'une boucle for basée sur l'étendue pour une chaîne :

UnicodeString string("C++11");
for (auto character : string) {
    std::wcout << character;		
}

Redéfinitions explicites de virtual

Concernant les redéfinitions de virtual, C++11 renforce plutôt les règles, afin de détecter des problèmes fréquents.

Dans ce but, C++11 introduit deux nouveaux mots clés contextuels :

  • final spécifie qu'une méthode ne peut pas être redéfinie ou qu'une classe ne peut pas être dérivée ;
  • override spécifie qu'une méthode redéfinit une méthode virtuelle déclarée dans l'une de ses classes parent.
Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Explicit virtual overrides.

Exemple Redéfinitions explicites de virtual

struct base {
        virtual void a();
        void b();
        virtual void c() final;
        virtual void d();
};

struct derived : base {
        void a() override; // correct
        void b() override; // error, an override can only be used for virtual functions
        void c() override; // error, cannot override a function marked as final
        int d() override; // error, different return type
};

Autoriser les constructeurs de déplacement à déclencher une exception [noexcept]

Le standard C++11 fournit une alternative à std::move, qui est std::move_if_noexcept, afin de résoudre une interaction problématique entre les constructeurs de déplacement, les templates et certaines fonctions membre de bibliothèque standard. 

std::move_if_noexcept(x) accorde l'autorisation de déplacer x sauf en présence d'une exception et si le type peut être copié.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Allowing move constructors to throw.

Définition de fonctions membre spéciales de déplacement

C++11 fournit un moyen de définir les fonctions membre spéciales de déplacement et de copie.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Defining move special member functions.

Opérations atomiques

C++11 ajoute les opérations et les types atomiques au standard. Les opérations et les types atomiques fournissent un moyen d'écrire des applications multi-thread sans utiliser de verrous.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Atomic operations.

Opération comparer-échanger forte

C++11 fournit à la fois les opérations comparer-échanger faible et forte. 

L'opération comparer-échanger est une opération atomique utilisée dans des applications multi-thread pour réaliser la synchronisation.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Strong Compare and Exchange.

Délimitations bidirectionnelles

Une délimitation est une primitive qui impose l'ordre entre les chargements et les stockages précédents, et les suivants. C++11 améliore le support des délimitations bidirectionnelles.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Bidirectional Fences.

Propagation des exceptions

Le standard C++11 offre la possibilité de déplacer une exception d'un thread à un autre. Dans ce but, certaines modifications ont été apportées à l'en-tête <exception>. 

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Propagating exceptions.

Autoriser l'usage des opérations atomiques dans les gestionnaires de signaux

C++11 autorise l'usage des opérations atomiques dans les gestionnaires de signaux.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition Allow atomics use in signal handlers.

Identificateur prédéfini __func__

Cette fonctionnalité est utilisée pour capturer les noms des fonctions sous forme de littéraux chaîne et aider les bibliothèques de diagnostics.

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition __func__ predefined identifier.

Préprocesseur C99

Le standard C++11 a pour objectif de resynchroniser le préprocesseur et les phases de translation de C++ avec C99, afin de renforcer la compatibilité entre les deux standards.

Les macros prédéfinies, l'opérateur pragma et la concaténation des littéraux chaîne comptent parmi les parties modifiées. 

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition C99 preprocessor.

Type long long

Par mesure de compatibilité avec C99, le standard C++11 introduit le type intégral long long. 

Pour de plus amples informations sur cette fonctionnalité, voir le document de proposition long long type.

Autres fonctionnalités

Voir aussi

Récupérée de « https://docwiki.embarcadero.com/RADStudio/Alexandria/f/index.php?title=Fonctionnalités_du_C%2B%2B_moderne_prises_en_charge_par_les_compilateurs_C%2B%2B_améliorés_par_Clang_de_RAD_Studio&oldid=217506 »