Sur cette page

QLoggingCategory Class

La classe QLoggingCategory représente une catégorie ou un "domaine" de l'infrastructure de journalisation. Plus d'informations...

En-tête : #include <QLoggingCategory>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core

Remarque : toutes les fonctions de cette classe sont sûres pour les threads.

Types publics

Fonctions publiques

QLoggingCategory(const char *category, QtMsgType enableForLevel = QtDebugMsg)
~QLoggingCategory()
const char *categoryName() const
bool isCriticalEnabled() const
bool isDebugEnabled() const
bool isEnabled(QtMsgType msgtype) const
bool isInfoEnabled() const
bool isWarningEnabled() const
void setEnabled(QtMsgType type, bool enable)
QLoggingCategory &operator()()
const QLoggingCategory &operator()() const

Membres publics statiques

QLoggingCategory *defaultCategory()
QLoggingCategory::CategoryFilter installFilter(QLoggingCategory::CategoryFilter filter)
void setFilterRules(const QString &rules)

Macros

(since 6.5) Q_DECLARE_EXPORTED_LOGGING_CATEGORY(name, EXPORT_MACRO)
Q_DECLARE_LOGGING_CATEGORY(name)
Q_LOGGING_CATEGORY(name, string)
Q_LOGGING_CATEGORY(name, string, msgType)
(since 6.9) Q_STATIC_LOGGING_CATEGORY(name, string)
(since 6.9) Q_STATIC_LOGGING_CATEGORY(name, string, msgType)
qCCritical(category)
qCCritical(category, const char *message, ...)
qCDebug(category)
qCDebug(category, const char *message, ...)
(since 6.5) qCFatal(category)
(since 6.5) qCFatal(category, const char *message, ...)
qCInfo(category)
qCInfo(category, const char *message, ...)
qCWarning(category)
qCWarning(category, const char *message, ...)

Description détaillée

QLoggingCategory représente une certaine catégorie de journalisation - identifiée par une chaîne - au moment de l'exécution. Une catégorie peut être configurée pour activer ou désactiver la journalisation des messages par type de message. Les messages fatals, qui sont toujours activés, constituent une exception.

Pour vérifier si un type de message est activé ou non, utilisez l'une des méthodes suivantes : isDebugEnabled(), isInfoEnabled(), isWarningEnabled() et isCriticalEnabled().

Tous les objets sont destinés à être configurés par un registre commun, comme décrit dans Configuring Categories. Des objets différents peuvent également représenter la même catégorie. Par conséquent, il n'est pas recommandé d'exporter des objets au-delà des limites des modules, de manipuler les objets directement ou d'hériter de QLoggingCategory.

Création d'objets de catégorie

Les macros Q_DECLARE_LOGGING_CATEGORY() et Q_LOGGING_CATEGORY() permettent de déclarer et de créer des objets QLoggingCategory :

// in a header
Q_DECLARE_LOGGING_CATEGORY(driverUsb)

// in one source file
Q_LOGGING_CATEGORY(driverUsb, "driver.usb")

Il existe également la macro Q_DECLARE_EXPORTED_LOGGING_CATEGORY() qui permet d'utiliser une catégorie de journalisation au-delà des limites de la bibliothèque.

Les noms des catégories sont en texte libre ; pour configurer les catégories à l'aide de Logging Rules, leurs noms doivent suivre cette convention :

  • Utiliser uniquement des lettres et des chiffres.
  • Utilisez des points pour structurer davantage les catégories en zones communes.
  • Évitez les noms de catégories : debug, info, warning, et critical.
  • Les noms de catégories avec le préfixe qt sont uniquement réservés aux modules Qt.

Les objets QLoggingCategory qui sont implicitement définis par Q_LOGGING_CATEGORY() sont créés lors de la première utilisation, de manière sûre pour les threads.

Vérification de la configuration de la catégorie

QLoggingCategory fournit isDebugEnabled(), isInfoEnabled(), isWarningEnabled(), isCriticalEnabled(), ainsi que isEnabled() pour vérifier si les messages du type donné doivent être enregistrés.

Les macros qCDebug(), qCWarning() et qCCritical() empêchent les arguments d'être évalués si les types de messages respectifs ne sont pas activés pour la catégorie, de sorte qu'une vérification explicite n'est pas nécessaire :

    // usbEntries() will only be called if driverUsb category is enabled
    qCDebug(driverUsb) << "devices: " << usbEntries();

Configuration de la catégorie par défaut

Le constructeur de QLoggingCategory et la macro Q_LOGGING_CATEGORY() acceptent tous deux un argument facultatif QtMsgType, qui désactive tous les types de messages de gravité inférieure. En d'autres termes, une catégorie déclarée avec

Q_LOGGING_CATEGORY(driverUsbEvents, "driver.usb.events", QtWarningMsg)

enregistre les messages de type QtWarningMsg, QtCriticalMsg, QtFatalMsg, mais ignore les messages de type QtDebugMsg et QtInfoMsg.

Si aucun argument n'est fourni, tous les messages sont enregistrés. Seules les catégories internes à Qt XML commençant par qt sont traitées différemment : Pour celles-ci, seuls les messages de type QtInfoMsg, QtWarningMsg, QtCriticalMsg, et QFatalMsg sont enregistrés par défaut.

Remarque : les catégories de journalisation ne sont pas affectées par votre configuration de compilation C++. En d'autres termes, l'impression des messages ne change pas selon que le code est compilé avec des symboles de débogage ("Debug Build"), des optimisations ("Release Build") ou une autre combinaison.

Configuration des catégories

Vous pouvez modifier la configuration par défaut des catégories en définissant des règles de journalisation ou en installant un filtre personnalisé.

Règles de journalisation

Les règles de journalisation vous permettent d'activer ou de désactiver la journalisation pour les catégories de manière flexible. Les règles sont spécifiées dans du texte, où chaque ligne doit avoir le format :

    <category>[.<type>] = true|false

<category> est le nom de la catégorie, éventuellement avec * comme symbole de remplacement pour le premier ou le dernier caractère, ou aux deux positions. L'option <type> doit être debug, info, warning, ou critical. Les lignes qui ne correspondent pas à ce schéma sont ignorées.

Les règles sont évaluées dans l'ordre du texte, de la première à la dernière. En d'autres termes, si deux règles s'appliquent à une catégorie/un type, c'est la règle qui vient en dernier qui est appliquée.

Les règles peuvent être définies via setFilterRules() :

    QLoggingCategory::setFilterRules("*.debug=false\n"
                                     "driver.usb.debug=true");

Les règles de journalisation sont automatiquement chargées à partir de la section [Rules] d'un fichier de configuration de la journalisation. Ces fichiers de configuration sont recherchés dans le répertoire de configuration de QtProject, ou explicitement définis dans une variable d'environnement QT_LOGGING_CONF:

    [Rules]
    *.debug=false
    driver.usb.debug=true

Les règles de journalisation peuvent également être spécifiées dans une variable d'environnement QT_LOGGING_RULES; plusieurs règles peuvent également être séparées par des points-virgules :

    QT_LOGGING_RULES=*.debug=false;driver.usb.debug=true

Les règles définies par setFilterRules() sont prioritaires sur les règles spécifiées dans le répertoire de configuration de QtProject. À leur tour, ces règles peuvent être remplacées par celles du fichier de configuration spécifié par QT_LOGGING_CONF, et par celles définies par QT_LOGGING_RULES.

L'ordre d'évaluation est le suivant :

  1. [QLibraryInfo::DataPath]/qtlogging.ini
  2. QtProject/qtlogging.ini
  3. setFilterRules()
  4. QT_LOGGING_CONF
  5. QT_LOGGING_RULES

Le fichier QtProject/qtlogging.ini est recherché dans tous les répertoires retournés par QStandardPaths::GenericConfigLocation.

Définissez la variable d'environnement QT_LOGGING_DEBUG pour savoir où vos règles de journalisation sont chargées.

Installation d'un filtre personnalisé

Comme alternative de bas niveau aux règles textuelles, vous pouvez également implémenter un filtre personnalisé via installFilter(). Dans ce cas, toutes les règles de filtrage sont ignorées.

Impression de la catégorie

Utilisez l'espace réservé %{category} pour imprimer la catégorie dans le gestionnaire de messages par défaut :

    qSetMessagePattern("%{category} %{message}");

Membre Type Documentation

QLoggingCategory::CategoryFilter

Il s'agit d'un typedef pour un pointeur sur une fonction avec la signature suivante :

void myCategoryFilter(QLoggingCategory *);

Une fonction portant cette signature peut être installée à l'aide de installFilter().

Documentation sur les fonctions membres

[explicit] QLoggingCategory::QLoggingCategory(const char *category, QtMsgType enableForLevel = QtDebugMsg)

Construit un objet QLoggingCategory avec le nom category fourni, et active tous les messages avec des types au moins aussi verbeux que enableForLevel, qui par défaut est QtDebugMsg (qui active toutes les catégories).

Si category est nullptr, le nom de catégorie "default" est utilisé.

Remarque : category doit rester valide pendant toute la durée de vie de cet objet. L'utilisation d'une chaîne littérale est le moyen habituel d'y parvenir.

[noexcept] QLoggingCategory::~QLoggingCategory()

Détruit un objet QLoggingCategory.

const char *QLoggingCategory::categoryName() const

Renvoie le nom de la catégorie.

[static] QLoggingCategory *QLoggingCategory::defaultCategory()

Renvoie un pointeur sur la catégorie globale "default" utilisée, par exemple, par qDebug(), qInfo(), qWarning(), qCritical() ou qFatal().

Remarque : le pointeur renvoyé peut être nul lors de la destruction d'objets statiques. De plus, il ne faut pas delete ce pointeur, car la propriété de la catégorie n'est pas transférée.

[static] QLoggingCategory::CategoryFilter QLoggingCategory::installFilter(QLoggingCategory::CategoryFilter filter)

Prendre le contrôle de la configuration des catégories de journalisation.

Installe une fonction filter qui est utilisée pour déterminer quelles catégories et quels types de messages doivent être activés. Si filter est nullptr, le filtre de messages par défaut est rétabli. Renvoie un pointeur sur le filtre précédemment installé.

Chaque objet QLoggingCategory existant est transmis au filtre avant le retour de installFilter(), et le filtre est libre de modifier la configuration de chaque catégorie à l'aide de setEnabled(). Toute catégorie qu'il ne modifie pas conservera la configuration qui lui a été donnée par le filtre précédent, de sorte que le nouveau filtre n'a pas besoin de déléguer au filtre précédent lors de ce passage initial sur les catégories existantes.

Toute nouvelle catégorie ajoutée ultérieurement sera transmise au nouveau filtre ; un filtre qui vise uniquement à modifier la configuration de quelques catégories sélectionnées, plutôt que de modifier complètement la politique de journalisation, peut d'abord transmettre la nouvelle catégorie au filtre précédent, pour lui donner sa configuration standard, puis la modifier à sa guise, s'il s'agit de l'une des catégories présentant un intérêt spécifique pour le filtre. Le code qui installe le nouveau filtre peut enregistrer le retour de installFilter() pour que le filtre puisse l'utiliser lors d'appels ultérieurs.

Lorsque vous définissez votre filtre, notez qu'il peut être appelé à partir de différents threads, mais jamais simultanément. Ce filtre ne peut pas appeler de fonctions statiques à partir de QLoggingCategory.

Exemple :

static QLoggingCategory::CategoryFilter oldCategoryFilter = nullptr;

void myCategoryFilter(QLoggingCategory *category)
{
    // For a category set up after this filter is installed, we first set it up
    // with the old filter. This ensures that any driver.usb logging configured
    // by the user is kept, aside from the one level we override; and any new
    // categories we're not interested in get configured by the old filter.
    if (oldCategoryFilter)
        oldCategoryFilter(category);

    // Tweak driver.usb's logging, over-riding the default filter:
    if (qstrcmp(category->categoryName(), "driver.usb") == 0)
        category->setEnabled(QtDebugMsg, true);
}

installé (dans main(), par exemple) par

oldCategoryFilter = QLoggingCategory::installFilter(myCategoryFilter);

Vous pouvez également configurer le filtre par défaut via setFilterRules().

bool QLoggingCategory::isCriticalEnabled() const

Renvoie true si des messages critiques doivent être affichés pour cette catégorie ; false dans le cas contraire.

Remarque : la macro qCCritical() effectue déjà cette vérification avant l'exécution de tout code. Cependant, l'appel à cette méthode peut être utile pour éviter la génération coûteuse de données destinées uniquement à la sortie de débogage.

bool QLoggingCategory::isDebugEnabled() const

Renvoie true si des messages de débogage doivent être affichés pour cette catégorie ; false dans le cas contraire.

Remarque : la macro qCDebug() effectue déjà cette vérification avant l'exécution de tout code. Toutefois, il peut être utile d'appeler cette méthode pour éviter la génération coûteuse de données destinées uniquement à la sortie de débogage.

bool QLoggingCategory::isEnabled(QtMsgType msgtype) const

Renvoie true si un message de type msgtype pour la catégorie doit être affiché ; false dans le cas contraire.

bool QLoggingCategory::isInfoEnabled() const

Renvoie true si des messages d'information doivent être affichés pour cette catégorie ; false dans le cas contraire.

Remarque : la macro qCInfo() effectue déjà cette vérification avant l'exécution de tout code. Cependant, l'appel à cette méthode peut être utile pour éviter la génération coûteuse de données destinées uniquement à la sortie de débogage.

bool QLoggingCategory::isWarningEnabled() const

Renvoie true si des messages d'avertissement doivent être affichés pour cette catégorie ; false dans le cas contraire.

Remarque : la macro qCWarning() effectue déjà cette vérification avant l'exécution de tout code. Toutefois, il peut être utile d'appeler cette méthode pour éviter la génération coûteuse de données destinées uniquement à la sortie de débogage.

void QLoggingCategory::setEnabled(QtMsgType type, bool enable)

Change le type de message type pour la catégorie en enable.

Cette méthode ne doit être utilisée qu'à l'intérieur d'un filtre installé avec installFilter(). Pour une vue d'ensemble de la configuration globale des catégories, voir Configuring Categories.

Remarque : QtFatalMsg ne peut pas être modifié ; il restera toujours true.

Voir également isEnabled().

[static] void QLoggingCategory::setFilterRules(const QString &rules)

Configure les catégories et les types de messages qui doivent être activés par le biais d'un ensemble de rules.

Exemple :

    QLoggingCategory::setFilterRules(QStringLiteral("driver.usb.debug=true"));

Note : Les règles peuvent être ignorées si un filtre de catégorie personnalisé est installé avec installFilter(), ou si l'utilisateur a défini la variable d'environnement QT_LOGGING_CONF ou QT_LOGGING_RULES.

QLoggingCategory &QLoggingCategory::operator()()

Renvoie l'objet lui-même. Cela permet d'utiliser à la fois une variable QLoggingCategory et une méthode d'usine qui renvoie un objet QLoggingCategory dans les macros qCDebug(), qCWarning(), qCCritical() ou qCFatal().

const QLoggingCategory &QLoggingCategory::operator()() const

Renvoie l'objet lui-même. Cela permet d'utiliser à la fois une variable QLoggingCategory et une méthode d'usine qui renvoie un objet QLoggingCategory dans les macros qCDebug(), qCWarning(), qCCritical() ou qCFatal().

Documentation sur les macros

[since 6.5] Q_DECLARE_EXPORTED_LOGGING_CATEGORY(name, EXPORT_MACRO)

Déclare une catégorie de journalisation name. Cette macro peut être utilisée pour déclarer une catégorie de journalisation commune à différentes parties du programme.

Elle fonctionne exactement comme Q_DECLARE_LOGGING_CATEGORY(). Cependant, la catégorie de journalisation déclarée par cette macro est qualifiée par EXPORT_MACRO. Ceci est utile si la catégorie de journalisation doit être exportée à partir d'une bibliothèque dynamique.

Par exemple, cette macro doit être utilisée en dehors d'une bibliothèque dynamique :

Q_DECLARE_EXPORTED_LOGGING_CATEGORY(lcCore, LIB_EXPORT_MACRO)

Cette macro doit être utilisée en dehors d'une classe ou d'une fonction.

Cette macro a été introduite dans Qt 6.5.

Voir aussi Q_LOGGING_CATEGORY() et Q_DECLARE_LOGGING_CATEGORY().

Q_DECLARE_LOGGING_CATEGORY(name)

Déclare une catégorie de journalisation name. La macro peut être utilisée pour déclarer une catégorie de journalisation commune partagée dans différentes parties du programme.

Cette macro doit être utilisée en dehors d'une classe ou d'une méthode.

Voir aussi Q_LOGGING_CATEGORY() et Q_DECLARE_EXPORTED_LOGGING_CATEGORY().

Q_LOGGING_CATEGORY(name, string)

Définit une catégorie de journalisation name, et la rend configurable sous l'identifiant string. Par défaut, tous les types de messages sont activés.

Une seule unité de traduction dans une bibliothèque ou un exécutable peut définir une catégorie avec un nom spécifique. L'objet QLoggingCategory, défini implicitement, est créé lors de la première utilisation, à l'abri des threads.

Cette macro doit être utilisée en dehors d'une classe ou d'une méthode.

Voir aussi Q_DECLARE_LOGGING_CATEGORY() et Q_DECLARE_EXPORTED_LOGGING_CATEGORY().

Q_LOGGING_CATEGORY(name, string, msgType)

Définit une catégorie de journalisation name, et la rend configurable sous l'identifiant string. Par défaut, les messages de QtMsgType msgType et plus graves sont activés, les types de gravité inférieure sont désactivés.

Une seule unité de traduction dans une bibliothèque ou un exécutable peut définir une catégorie avec un nom spécifique. L'objet QLoggingCategory implicitement défini est créé lors de la première utilisation, à l'abri des threads.

Cette macro doit être utilisée en dehors d'une classe ou d'une méthode.

Voir aussi Q_DECLARE_LOGGING_CATEGORY().

[since 6.9] Q_STATIC_LOGGING_CATEGORY(name, string)

Définit une catégorie de journalisation statique name, et la rend configurable sous l'identifiant string. Par défaut, tous les types de messages sont activés.

La catégorie de journalisation est créée à l'aide du qualificateur static de sorte que vous ne puissiez y accéder que dans la même unité de traduction. Cela permet d'éviter les collisions accidentelles de symboles.

L'objet QLoggingCategory, défini implicitement, est créé lors de la première utilisation, à l'abri des threads.

Cette macro doit être utilisée en dehors d'une classe ou d'une méthode.

Cette macro a été introduite dans Qt 6.9.

Voir aussi Q_LOGGING_CATEGORY().

[since 6.9] Q_STATIC_LOGGING_CATEGORY(name, string, msgType)

Définit une catégorie de journalisation statique name, et la rend configurable sous l'identifiant string. Par défaut, les messages de QtMsgType msgType et plus graves sont activés, les types de gravité inférieure sont désactivés.

La catégorie de journalisation est créée à l'aide du qualificateur static, de sorte qu'elle n'est accessible que dans la même unité de traduction. Cela permet d'éviter les collisions accidentelles de symboles.

L'objet QLoggingCategory, défini implicitement, est créé lors de la première utilisation, à l'abri des threads.

Cette macro doit être utilisée en dehors d'une classe ou d'une méthode.

Cette macro a été introduite dans Qt 6.9.

Voir aussi Q_LOGGING_CATEGORY().

qCCritical(category)

Renvoie un flux de sortie pour les messages critiques dans la catégorie de journalisation, category.

La macro se développe en code qui vérifie si QLoggingCategory::isCriticalEnabled() est évalué à true. Si c'est le cas, les arguments du flux sont traités et envoyés au gestionnaire de messages.

Exemple :

    QLoggingCategory category("driver.usb");
    qCCritical(category) << "a critical message";

Remarque : si la sortie critique pour une catégorie particulière n'est pas activée, les arguments ne seront pas traités, il ne faut donc pas compter sur les effets de bord.

Voir aussi QDebug::qCritical().

qCCritical(category, const char *message, ...)

Enregistre un message critique, message, dans la catégorie d'enregistrement, category. message peut contenir des caractères de remplacement à remplacer par des arguments supplémentaires, comme dans la fonction printf() du langage C.

Exemple :

    QLoggingCategory category("driver.usb");
    qCCritical(category, "a critical message logged into category %s", category.categoryName());

Note : Si la sortie critique pour une catégorie particulière n'est pas activée, les arguments ne seront pas traités, il ne faut donc pas compter sur les effets de bord.

Voir aussi qCritical(const char *, ...).

qCDebug(category)

Renvoie un flux de sortie pour les messages de débogage dans la catégorie de journalisation, category.

La macro se développe en code qui vérifie si QLoggingCategory::isDebugEnabled() est évalué à true. Si c'est le cas, les arguments du flux sont traités et envoyés au gestionnaire de messages.

Exemple :

    QLoggingCategory category("driver.usb");
    qCDebug(category) << "a debug message";

Remarque : les arguments ne sont pas traités si la sortie de débogage pour cette category n'est pas activée, donc ne vous fiez pas aux effets secondaires.

Voir aussi QDebug::qDebug().

qCDebug(category, const char *message, ...)

Enregistre un message de débogage, message, dans la catégorie d'enregistrement, category. message peut contenir des caractères de remplacement à remplacer par des arguments supplémentaires, comme la fonction printf() du langage C.

Exemple :

    QLoggingCategory category("driver.usb");
    qCDebug(category, "a debug message logged into category %s", category.categoryName());

Note : Les arguments ne sont pas traités si la sortie de débogage pour cette category n'est pas activée, donc ne vous fiez pas aux effets secondaires.

Voir aussi qDebug(const char *, ...).

[since 6.5] qCFatal(category)

Renvoie un flux de sortie pour les messages fatals dans la catégorie de journalisation, category.

Si vous utilisez le gestionnaire de messages par défaut, le flux retourné sera interrompu pour créer un core dump. Sous Windows, pour les versions de débogage, cette fonction renvoie une adresse _CRT_ERROR qui vous permet de connecter un débogueur à l'application.

Exemple :

    QLoggingCategory category("driver.usb");
    qCFatal(category) << "a fatal message. Program will be terminated!";

Cette macro a été introduite dans Qt 6.5.

Voir aussi QDebug::qFatal().

[since 6.5] qCFatal(category, const char *message, ...)

Enregistre un message fatal, message, dans la catégorie d'enregistrement, category. message peut contenir des caractères de remplacement à remplacer par des arguments supplémentaires, comme la fonction printf() du langage C.

Exemple :

    QLoggingCategory category("driver.usb");
    qCFatal(category, "a fatal message. Program will be terminated!");

Si vous utilisez le gestionnaire de messages par défaut, cette fonction s'interrompra pour créer un core dump. Sous Windows, pour les versions de débogage, cette fonction signalera une adresse _CRT_ERROR vous permettant de connecter un débogueur à l'application.

Cette macro a été introduite dans Qt 6.5.

Voir aussi qFatal(const char *, ...).

qCInfo(category)

Renvoie un flux de sortie pour les messages d'information dans la catégorie de journalisation, category.

La macro se développe en code qui vérifie si QLoggingCategory::isInfoEnabled() est évalué à true. Si c'est le cas, les arguments du flux sont traités et envoyés au gestionnaire de messages.

Exemple :

    QLoggingCategory category("driver.usb");
    qCInfo(category) << "an informational message";

Remarque : si la sortie de débogage pour une catégorie particulière n'est pas activée, les arguments ne seront pas traités, il ne faut donc pas compter sur les effets de bord.

Voir aussi QDebug::qInfo().

qCInfo(category, const char *message, ...)

Enregistre un message d'information, message, dans la catégorie d'enregistrement, category. message peut contenir des caractères de remplacement à remplacer par des arguments supplémentaires, comme la fonction printf() du langage C.

Exemple :

    QLoggingCategory category("driver.usb");
    qCInfo(category, "an informational message logged into category %s", category.categoryName());

Note : Si la sortie de débogage pour une catégorie particulière n'est pas activée, les arguments ne seront pas traités, donc ne vous fiez pas aux effets de bord.

Voir aussi qInfo(const char *, ...).

qCWarning(category)

Renvoie un flux de sortie pour les messages d'avertissement dans la catégorie de journalisation, category.

La macro se développe en code qui vérifie si QLoggingCategory::isWarningEnabled() est évalué à true. Si c'est le cas, les arguments du flux sont traités et envoyés au gestionnaire de messages.

Exemple :

    QLoggingCategory category("driver.usb");
    qCWarning(category) << "a warning message";

Remarque : si la sortie d'avertissement pour une catégorie particulière n'est pas activée, les arguments ne seront pas traités, il ne faut donc pas compter sur les effets de bord.

Voir aussi QDebug::qWarning().

qCWarning(category, const char *message, ...)

Enregistre un message d'avertissement, message, dans la catégorie d'enregistrement, category. message peut contenir des caractères de remplacement à remplacer par des arguments supplémentaires, comme dans la fonction printf() du langage C.

Exemple :

    QLoggingCategory category("driver.usb");
    qCWarning(category, "a warning message logged into category %s", category.categoryName());

Note : Si la sortie d'avertissement pour une catégorie particulière n'est pas activée, les arguments ne seront pas traités, donc ne vous fiez pas aux effets de bord.

Voir aussi qWarning(const char *, ...).

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.