<QtCompilerDetection> - Compiler-specific Macro Definitions

Documentation sur les macros

Q_CC_BOR

Défini si l'application est compilée avec Borland/Turbo C++.

Q_CC_CDS

Défini si l'application est compilée avec Reliant C++.

Q_CC_CLANG

Défini si l'application est compilée avec Clang.

Q_CC_COMEAU

Défini si l'application est compilée avec Comeau C++.

Q_CC_DEC

Défini si l'application est compilée avec DEC C++.

Q_CC_EDG

Défini si l'application est compilée avec Edison Design Group C++.

Q_CC_GHS

Défini si l'application est compilée à l'aide des compilateurs C++ optimisés de Green Hills.

Q_CC_GNU

Défini si l'application est compilée à l'aide de GNU Compiler Collection (GCC).

Q_CC_HIGHC

Défini si l'application est compilée à l'aide de MetaWare High C/C++.

Q_CC_HPACC

Défini si l'application est compilée avec HP aC++.

Q_CC_KAI

Défini si l'application est compilée avec KAI C++.

Q_CC_MIPS

Défini si l'application est compilée avec MIPSpro C++.

Q_CC_MSVC

Défini si l'application est compilée à l'aide de Microsoft Visual C/C++, Intel C++ pour Windows.

Q_CC_OC

Défini si l'application est compilée avec CenterLine C++.

Q_CC_PGI

Défini si l'application est compilée à l'aide de Portland Group C++.

Q_CC_SUN

Défini si l'application est compilée à l'aide de Forte Developer ou de Sun Studio C++.

Q_CC_SYM

Défini si l'application est compilée avec Digital Mars C/C++ (anciennement Symantec C++).

Q_CC_USLC

Défini si l'application est compilée à l'aide de SCO OUDK et UDK.

Q_CC_WAT

Défini si l'application est compilée avec Watcom C++.

[since 6.9] Q_CONSTEXPR_DTOR

S'étend jusqu'à constexpr sur les compilateurs prenant en charge C++20, lorsque __cpp_constexpr a une valeur supérieure ou égale à 201907L. Sinon, elle se développe en const.

Utilisez cette macro pour déclarer une variable qui peut être construite au moment de la compilation en C++20 ou plus.

Cette macro a été introduite dans Qt 6.9.

Voir aussi Q_DECL_CONSTEXPR_DTOR.

[since 6.4] Q_CONSTINIT

Renforce l'initialisation des constantes lorsque le compilateur le permet.

Si le compilateur supporte le mot-clé C++20 constinit, Clang's [[clang::require_constant_initialization]] ou GCC's __constinit, alors cette macro se développe vers le premier de ces mots-clé qui est disponible, sinon elle se développe vers rien.

Les variables marquées comme constinit provoquent une erreur de compilation si leur initialisation doit être effectuée au moment de l'exécution.

Pour les constantes, vous pouvez utiliser constexpr depuis C++11, mais constexpr rend les variables const, également, alors que constinit assure l'initialisation de la constante, mais ne rend pas la variable const:

Si la déclaration et la définition d'une variable Q_CONSTINIT sont séparées, cette macro ne s'applique qu'à la définition, et non à la déclaration :

class C {
    ~~~~
    static int count; // declaration, no Q_CONSTINIT here
};
~~~
Q_CONSTINIT int C::count = 0; // definition

Cette macro a été introduite dans Qt 6.4.

[since 6.9] Q_DECL_CONSTEXPR_DTOR

S'étend jusqu'à constexpr sur les compilateurs prenant en charge C++20, lorsque __cpp_constexpr a une valeur supérieure ou égale à 201907L. Sinon, elle se développe en inline.

Utilisez cette macro pour déclarer un destructeur qui peut être calculé au moment de la compilation en C++20 ou plus.

Cette macro a été introduite dans Qt 6.9.

Voir aussi Q_CONSTEXPR_DTOR.

[since 6.9] Q_DECL_EQ_DELETE_X(reason)

Se développe jusqu'à = delete(reason) sur les compilateurs qui prennent en charge C++26, lorsque __cpp_deleted_function a une valeur supérieure ou égale à 202403L. Sinon, elle se développe en = delete.

Utilisez cette macro pour déclarer une fonction supprimée et fournir un message d'erreur ( reason) à l'utilisateur au cas où la fonction serait utilisée (en expliquant pourquoi la fonction a été supprimée).

Cette macro a été introduite dans Qt 6.9.

Q_DECL_EXPORT

Cette macro marque un symbole pour l'exportation de bibliothèques partagées (voir Création de bibliothèques partagées).

Voir aussi Q_DECL_IMPORT.

Q_DECL_IMPORT

Cette macro déclare qu'un symbole est importé d'une bibliothèque partagée (voir Création de bibliothèques partagées).

Voir aussi Q_DECL_EXPORT.

void Q_FALLTHROUGH()

Peut être utilisé dans les instructions switch à la fin d'un bloc case pour indiquer au compilateur et aux autres développeurs que l'absence d'instruction break est intentionnelle.

C'est utile car une instruction break manquante est souvent un bogue, et certains compilateurs peuvent être configurés pour émettre des avertissements lorsqu'une instruction break n'est pas trouvée.

Voir également Q_UNREACHABLE() et Q_UNREACHABLE_RETURN().

const char*Q_FUNC_INFO()

Se développe en une chaîne de caractères qui décrit la fonction dans laquelle la macro réside. L'aspect de cette chaîne dépend du compilateur. Avec GNU GCC, il s'agit généralement de la signature de la fonction, tandis qu'avec d'autres compilateurs, il peut s'agir du numéro de ligne et de colonne.

Q_FUNC_INFO peut être utilisé de manière pratique avec qDebug(). Par exemple, cette fonction :

template<typename TInputType>const TInputType &myMin(const TInputType &valeur1, const TInputType &valeur2){
    qDebug() << Q_FUNC_INFO << "was called with value1:" << value1 << "value2:" << value2;

   if(value1 < value2) return value1 ; else return value2 ; }

lorsqu'il est instancié avec le type integer, produira avec le compilateur GCC :

const TInputType& myMin(const TInputType&, const TInputType&) [with TInputType = int] was called with value1: 3 value2: 4

Si cette macro est utilisée en dehors d'une fonction, le comportement est indéfini.

Q_LIKELY(expr)

Indique au compilateur que la condition incluse, expr, est susceptible d'être évaluée à true.

L'utilisation de cette macro peut aider le compilateur à optimiser le code.

Exemple :

    // the condition inside the "if" will be successful most of the times
    for (int i = 1; i <= 365; i++) {
        if (Q_LIKELY(isWorkingDay(i))) {
            //...
        }
        //...
    }

Voir également Q_UNLIKELY(), Q_LIKELY_BRANCH, et Q_UNLIKELY_BRANCH.

[since 6.9] Q_LIKELY_BRANCH

Indique au compilateur que le bloc suivant est susceptible d'être exécuté.

L'utilisation de cette macro peut aider le compilateur à optimiser le code.

Elle est définie comme l'attribut C++20 [[likely]], et n'est pas utilisable par les compilateurs qui ne la supportent pas.

Cette macro a été introduite dans Qt 6.9.

Voir aussi Q_LIKELY(), Q_UNLIKELY(), et Q_UNLIKELY_BRANCH.

[since 6.6] Q_NODISCARD_CTOR

S'étend jusqu'à [[nodiscard]] sur les compilateurs qui l'acceptent sur les constructeurs.

Sinon, il ne se développe pas du tout.

Les constructeurs marqués comme Q_NODISCARD_CTOR provoquent un avertissement du compilateur si un site d'appel n'utilise pas l'objet résultant.

Cette macro existe uniquement pour éviter les avertissements sur les compilateurs qui n'implémentent pas cette fonctionnalité. Si vos plateformes supportées autorisent toutes [[nodiscard]] sur les constructeurs, nous vous recommandons fortement d'utiliser l'attribut C++ directement au lieu de cette macro.

Cette macro a été introduite dans Qt 6.6.

Voir aussi Q_NODISCARD_CTOR_X.

Ils s'étendent jusqu'à [[nodiscard(message)]] pour les compilateurs qui prennent en charge cette fonctionnalité.

Sinon, elles se développent en [[nodiscard]] et Q_NODISCARD_CTOR, respectivement.

Ces macros ont été introduites dans Qt 6.7.

Voir aussi Q_NODISCARD_CTOR.

Q_UNLIKELY(expr)

Indique au compilateur que la condition incluse, expr, est susceptible d'être évaluée à false.

L'utilisation de cette macro peut aider le compilateur à optimiser le code.

Exemple :

bool readConfiguration(const QFile &file) { // Nous nous attendons à ce qu'on nous demande de lire un fichier existant if (Q_UNLIKELY(!file.exists())) {        qWarning() << "File not found";
       return false; } //... return true; }

Voir aussi Q_LIKELY(), Q_LIKELY_BRANCH, et Q_UNLIKELY_BRANCH.

[since 6.9] Q_UNLIKELY_BRANCH

Indique au compilateur qu'il est peu probable que le bloc suivant soit exécuté.

L'utilisation de cette macro peut aider le compilateur à optimiser le code.

Elle est définie comme l'attribut C++20 [[unlikely]], et n'est pas utilisable par les compilateurs qui ne la supportent pas.

Cette macro a été introduite dans Qt 6.9.

Voir aussi Q_LIKELY(), Q_UNLIKELY(), et Q_LIKELY_BRANCH.