Compilateurs C++ améliorés par Clang

De RAD Studio
Aller à : navigation, rechercher

Remonter à Compilateurs C++


La dernière génération des compilateurs C++ de RAD Studio est basée sur le compilateur Clang (EN) open-source, qui représente le frontal de l'infrastructure du compilateur LLVM (EN).

RAD Studio fournit les compilateurs C++ suivants améliorés par Clang :

Compilateur Plate-forme Version de Clang Version de LLVM
BCC32C Windows 32 bits 3.3 3.3
BCC32X [1] Windows 32 bits 3.3 3.3
BCC64 Windows 64 bits 3.3 3.3
BCCIOSARM iOS 32 bits 3.3 3.3
BCCIOSARM64 iOS 64 bits 3.3 3.5
BCCAARM Android 3.3 3.3
  1. BCC32X utilise les indicateurs en ligne de commande Clang par mesure de compatibilité avec d'autres compilateurs basés sur Clang (BCC64, BCCIOSARM, BCCIOSARM64 et BCCAARM). BCC32C est compatible avec les indicateurs de compilateur classiques (BCC32).

Différences entre les compilateurs C++ améliorés par Clang et les compilateurs C++ de précédente génération

Les compilateurs C++ améliorés par Clang ont une base de code entièrement nouvelle, et ils sont très différents des compilateurs C++ de précédente génération de RAD Studio :

Voici quelques différences significatives entre les compilateurs C++ améliorés par Clang et les deux compilateurs C++ de précédente génération :

  • Les compilateurs C++ améliorés par Clang sont aussi des préprocesseurs lorsqu'ils sont exécutés avec le commutateur -E.
    Pour Windows 64 bits, il existe également un préprocesseur CPP64.EXE distinct.
  • Les compilateurs C++ améliorés par Clang imposent la recherche de modèles en deux phases.
    Ce qui signifie que les noms qui ne sont pas liés à un type dépendant sont recherchés lors de la première phase (avant l'instanciation) et peuvent provoquer des erreurs que les compilateurs C++ de précédente génération ne signalaient pas. Lors de la deuxième phase (instanciation), le code du modèle est à nouveau contrôlé pour vérifier que tous les appels sont valides pour les types dépendants. Pour plus d'informations, voir Two-phase name lookup for Clang.

Par ex. : le modèle peut effectuer plusieurs appels à des fonctions qui ne sont peut-être pas présentes pour ce type particulier.

  • Les compilateurs C++ améliorés par Clang n'autorisent un argument par défaut que dans une déclaration de fonction.
    Les compilateurs C++ de précédente génération autorisent également les arguments par défaut dans un pointeur de fonction ou une déclaration de clôture.
  • Les compilateurs C++ améliorés par Clang n'autorisent pas l'utilisation de sizeof dans une directive du préprocesseur, telle que #if sizeof(ATypeName) > 20.
  • Les compilateurs C++ améliorés par Clang sont plus stricts concernant les conversions.
    Par exemple, la conversion de constantes chaîne en char * génère un avertissement (la conversion d'un littéral chaîne en char * est désapprouvée). D'autre part, l'initialisation d'un char * avec un unsigned char * génère une erreur (Impossible d'initialiser une variable de type 'char *' avec une rvalue de type BYTE *, aussi connue comme unsigned char *).
  • Les compilateurs C++ améliorés par Clang n'autorisent pas la combinaison de __try avec catch : en effet, catch doit être utilisé avec try, et __try doit être utilisé avec __except ou __finally, voire les deux.
  • Les identificateurs Unicode ne sont pas pris en charge par les compilateurs C++ améliorés par Clang.
  • CPP32 prend en charge l'option -Hp et imprime les informations de garde des en-têtes utilisées par l'expert En-tête précompilé.
  • Le style Unix #line n'est pas la valeur #line par défaut de CPP32, et ainsi de suite.
  • Les compilateurs C++ améliorés par Clang ne prennent pas en charge les attributs C++11 final, deprecated et noreturn. Voir Solution pour les attributs C++11 pour trouver une solution de contournement dans les compilateurs C++ améliorés par Clang.
  • De nombreuses options des compilateurs C++ de précédente génération ne sont pas prises en charge par les compilateurs C++ améliorés par Clang, et vice versa :
  • Les compilateurs C++ améliorés par C ne traitent pas __FUNC__ en tant que macro prédéfinie. C'est plutôt un identificateur prédéfini (une variable function-local prédéfinie) qui capture les noms de fonction en tant que tableau de caractères statique.

Pour de plus amples informations, voir Différences entre les compilateurs C++ améliorés par Clang et les compilateurs C++ de précédente génération.

Comment les options du compilateur C++ de précédente génération sont converties en options des compilateurs C++ améliorés par Clang

Voir Options de projet prises en charge par les compilateurs C++ améliorés par Clang.

Problèmes fréquents lors de la compilation d'un projet du compilateur C++ de précédente génération avec les compilateurs C++ améliorés par Clang

Il est probable que vous rencontrerez de nouvelles erreurs dues à la rigueur de la conformité ANSI des compilateurs C++ améliorés par Clang.

Pour de plus amples informations, voir :

Prise en charge des en-têtes précompilés

Les compilateurs C++ améliorés par Clang prennent en charge l'utilisation d'un en-tête précompilé, nommé par défaut <projet><n>PCH.h.

Pour de plus amples informations, voir Utilisation des en-têtes précompilés avec les compilateurs C++ améliorés par Clang.

Macros prédéfinies

Les macros prédéfinies prises en charge par les compilateurs améliorés par Clang sont nombreuses. Par exemple, BCCIOSARM prend en charge des définitions telles que __APPLE__ et __BCCPLUSPLUS__.

Pour afficher toutes les macros prédéfinies qui sont prises en charge, utilisez l'interface de ligne de commande de votre compilateur, comme suit :

echo | <compiler> -E -dM -

L'option -E exécute le préprocesseur uniquement. -dM vide toutes les macros définies lors du prétraitement et s'arrête. Le - final prend l'entrée de stdin, qui est envoyée via le canal à partir de l'echo vide.

Pour de plus amples informations, voir Macros prédéfinies.

Mots clés

Cette section contient une liste alphabétique des mots clés C++ qui nécessitent un traitement spécial lors de leur utilisation avec les compilateurs C++ améliorés par Clang ou qui ne sont pas pris en charge par ces compilateurs.

Pris en charge Non pris en charge

Voir Solution pour les attributs C++11 (compilateurs C++ améliorés par Clang) pour savoir comment remplacer la fonctionnalité des mots clés qui ne sont pas pris en charge dans les compilateurs C++ améliorés par Clang.

Le comptage automatique des références peut être activé par défaut

Les compilateurs Delphi basés sur LLVM utilisent le comptage automatique des références (ARC). Si le compilateur Delphi d'une certaine plate-forme cible est basé sur LLVM, le compilateur C++ correspondant amélioré par Clang active automatiquement ARC. L'activation d'ARC est équivalente à la transmission du commutateur -fborland-auto-refcount à l'interface de ligne de commande du compilateur C++.

Le tableau suivant présente les compilateurs C++ améliorés par Clang pour lesquels la fonction ARC est activée par défaut :

Plate-forme Compilateur Delphi Compilateur C++ Fonction ARC activée par défaut

Windows 32 bits

DCC32

BCC32C

Non

Windows 64 bits

DCC64

BCC64

Non

iOS 32 bits

DCCIOSARM

BCCIOSARM

Oui

iOS 64 bits

DCCIOSARM64

BCCIOSARM64

Oui

Android

DCCAARM

BCCAARM

Oui

Remarque : Ne désactivez pas ARC sur la ligne de commande. Il est requis pour travailler avec les frameworks FireMonkey et RTL.}}

Utilisation de la compilation parallèle

La compilation parallèle permet aux compilateurs de traiter simultanément plusieurs fichiers source, en utilisant les coeurs distincts du processeur système, afin de réduire de façon significative la durée de la compilation.

Pour activer la compilation parallèle dans l'EDI pour un projet C++ donné, ouvrez le projet cible et suivez ces étapes :

  1. Sélectionnez Projet > Options > Compilateur C++, et activez l'option "Activer la compilation groupée" sous Compilation générale.
  2. Sélectionnez Projet > Options > Propriétés de projet et :
    1. Activez l'option "Exécuter le compilateur C++ dans un processus distinct".
    2. Sélectionnez le nombre de sous-processus parallèles à utiliser.
      Remarque : Le nombre de sous-processus que vous choisissez ne peut pas être supérieur au nombre de coeurs de votre CPU.

Rubriques

Voir aussi