<QtCompilerDetection> - Compiler-specific Macro Definitions

Documentation sur les macros

Q_CC_BOR

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

Q_CC_CDS

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

Q_CC_CLANG

Défini si l'application est compilée à l'aide de Clang.

Q_CC_COMEAU

Défini si l'application est compilée à l'aide de 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 à l'aide d'Edison Design Group C++.

Q_CC_GHS

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

Q_CC_GNU

Défini si l'application est compilée à l'aide de la 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 à l'aide de HP aC++.

Q_CC_KAI

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

Q_CC_MIPS

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

Q_CC_MSVC

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

Q_CC_OC

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

Q_CC_PGI

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

Q_CC_SUN

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

Q_CC_SYM

Cette variable est définie si l'application est compilée à l'aide de 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 à l'aide de Watcom C++.

[since 6.9] Q_CONSTEXPR_DTOR

Se développe en « constexpr » sur les compilateurs prenant en charge C++20, lorsque la valeur de « __cpp_constexpr » est supérieure ou égale à « 201907L ». Dans le cas contraire, elle se développe en « const ».

Utilisez cette macro pour déclarer une variable pouvant être construite à la compilation en C++20 ou versions ultérieures.

Cette macro a été introduite dans Qt 6.9.

Voir également Q_DECL_CONSTEXPR_DTOR.

[since 6.4] Q_CONSTINIT

Impose l'initialisation à une valeur constante lorsque le compilateur le prend en charge.

Si le compilateur prend en charge le mot-clé C++20 « constinit », « [[clang::require_constant_initialization]] » de Clang ou « __constinit » de GCC, cette macro se développe alors en la première de ces options disponible ; dans le cas contraire, elle ne se développe pas.

Les variables marquées comme « constinit » provoquent une erreur de compilation si leur initialisation devait être effectuée lors de l'exécution.

Pour les constantes, vous pouvez utiliser ` constexpr ` depuis C++11, mais ` constexpr ` rend également les variables ` const`, tandis que ` constinit ` garantit une initialisation constante, sans pour autant rendre la variable ` const` :

Si la déclaration et la définition d'une variable Q_CONSTINIT sont séparées, cette macro s'applique uniquement à 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

Se développe en ` constexpr ` sur les compilateurs prenant en charge C++20, lorsque ` __cpp_constexpr ` a une valeur supérieure ou égale à ` 201907L`. Dans le cas contraire, il se développe en ` inline`.

Utilisez cette macro pour déclarer un destructeur pouvant être calculé à la compilation en C++20 ou versions ultérieures.

Cette macro a été introduite dans Qt 6.9.

Voir également Q_CONSTEXPR_DTOR.

[since 6.9] Q_DECL_EQ_DELETE_X(reason)

Se développe en = delete(reason) sur les compilateurs prenant 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 également un message d'erreur ( reason) à l'utilisateur au cas où la fonction serait utilisée (en expliquant pourquoi elle a été supprimée).

Cette macro a été introduite dans Qt 6.9.

Q_DECL_EXPORT

Cette macro désigne un symbole destiné à être exporté par une bibliothèque partagée (voir « Création de bibliothèques partagées »).

Voir également Q_DECL_IMPORT.

Q_DECL_IMPORT

Cette macro déclare un symbole comme étant une importation provenant d'une bibliothèque partagée (voir « Création de bibliothèques partagées »).

Voir également Q_DECL_EXPORT.

[since 6.12] Q_DECL_NONALLOCATING_FUNCTION

Se développe en ` [[clang::nonallocating]] ` sur les compilateurs Clang prenant en charge cette fonctionnalité.

Indique que la fonction n'alloue jamais de mémoire sur le tas et ne lève jamais d'exception.

Utilisée par l’analyse des effets des fonctions (Function Effect Analysis ) et le sanitiseur en temps réel (Realtime Sanitizer) de Clang.

Cette macro a été introduite dans Qt 6.12.

Voir également Q_DECL_NONBLOCKING_FUNCTION.

[since 6.12] Q_DECL_NONBLOCKING_FUNCTION

Se développe en ` [[clang::nonblocking]] ` sur les compilateurs Clang prenant en charge cette fonctionnalité.

Indique que la fonction ne se bloque jamais sur un verrou, n'alloue jamais de mémoire sur le tas et ne lève jamais d'exception.

Utilisée par l'analyse des effets de fonction et le sanitizer en temps réel de Clang.

Cette macro a été introduite dans Qt 6.12.

Voir également Q_DECL_NONALLOCATING_FUNCTION.

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.

Cela s'avère utile car l'absence d'une instruction `break` est souvent le signe d'un bug, et certains compilateurs peuvent être configurés pour émettre des avertissements lorsqu'ils n'en trouvent pas.

Voir également Q_UNREACHABLE() et Q_UNREACHABLE_RETURN().

const char *Q_FUNC_INFO

Se développe en une chaîne de caractères décrivant la fonction dans laquelle se trouve la macro. La forme exacte 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 &value1, const TInputType &value2)
{
    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 entier, 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 de donner comme résultat 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'a aucun effet sur les compilateurs qui ne la prennent pas en charge.

Cette macro a été introduite dans Qt 6.9.

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

[since 6.6] Q_NODISCARD_CTOR

Se développe en « [[nodiscard]] » sur les compilateurs qui l'acceptent dans les constructeurs.

Sinon, il ne donne lieu à aucune expansion.

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 toutes vos plateformes prises en charge autorisent l’ [[nodiscard]] e sur les constructeurs, nous vous recommandons vivement d’utiliser directement l’attribut C++ plutôt que cette macro.

Cette macro a été introduite dans Qt 6.6.

Voir aussi Q_NODISCARD_CTOR_X.

Développer en [[nodiscard(message)]] sur les compilateurs prenant en charge cette fonctionnalité.

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

Ces macros ont été introduites dans Qt 6.7.

Voir également Q_NODISCARD_CTOR.

Q_UNLIKELY(expr)

Indique au compilateur que la condition incluse, expr, est susceptible de donner comme résultat false.

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

Exemple :

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

    //...
    return true;
}

Voir également Q_LIKELY(), Q_LIKELY_BRANCH et Q_UNLIKELY_BRANCH.

[since 6.9] Q_UNLIKELY_BRANCH

Indique au compilateur que le bloc suivant a peu de chances 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 « [[unlikely]] » et n'a aucun effet sur les compilateurs qui ne la prennent pas en charge.

Cette macro a été introduite dans Qt 6.9.

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