QLoggingCategory Class
La classe QLoggingCategory représente une catégorie, ou un « domaine », au sein de l'infrastructure de journalisation. En savoir plus...
| 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 catégorie de journalisation spécifique – identifiée par une chaîne de caractères – lors 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 constituent une exception : ils sont toujours activés.
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 via un registre commun, comme décrit dans Configuring Categories. Différents objets 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 d’un module, 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 facilement 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 d’une bibliothèque.
Les noms de catégories sont librement définissables ; pour configurer des catégories à l’aide de Logging Rules, leurs noms doivent respecter la convention suivante :
- Utilisez uniquement des lettres et des chiffres.
- Utilisez des points pour structurer davantage les catégories en domaines communs.
- Évitez les noms de catégories suivants :
debug,info,warningetcritical. - Les noms de catégories préfixés par «
qt» sont exclusivement réservés aux modules Qt.
Les objets QLoggingCategory définis implicitement par Q_LOGGING_CATEGORY() sont créés lors de leur première utilisation, de manière sûre pour les threads.
Vérification de la configuration des catégories
QLoggingCategory fournit les méthodes isDebugEnabled(), isInfoEnabled(), isWarningEnabled(), isCriticalEnabled(), ainsi que isEnabled() pour vérifier si les messages d’un type donné doivent être consignés.
Les macros qCDebug(), qCWarning() et qCCritical() empêchent l’évaluation des arguments si les types de messages correspondants ne sont pas activés pour la catégorie, ce qui rend toute vérification explicite superflue :
// usbEntries() will only be called if driverUsb category is enabled
qCDebug(driverUsb) << "devices: " << usbEntries();Configuration par défaut de la catégorie
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 dont la gravité est inférieure. Autrement dit, 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 passé, tous les messages sont consignés. Seules les catégories internes à Qt commençant par qt sont traitées différemment : pour celles-ci, seuls les messages de type QtInfoMsg, QtWarningMsg, QtCriticalMsg et QFatalMsg sont consignés par défaut.
Remarque : les catégoriesde journalisation ne sont pas affectées par votre configuration de compilation C++. Autrement dit, l'affichage des messages ne varie pas selon que le code est compilé avec des symboles de débogage (« Debug Build »), des optimisations (« Release Build ») ou toute autre combinaison.
Configuration des catégories
Vous pouvez remplacer la configuration par défaut des catégories soit en définissant des règles de journalisation, soit 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 sous forme de texte, chaque ligne devant respecter le format suivant :
<category>[.<type>] = true|false<category> est le nom de la catégorie, pouvant comporter * comme caractère générique pour le premier ou le dernier caractère, voire aux deux positions. L’ <type>, facultatif, doit être debug, info, warning ou critical. Les lignes qui ne respectent pas ce schéma sont ignorées.
Les règles sont évaluées dans l'ordre dans lequel elles apparaissent dans le texte, de la première à la dernière. Autrement dit, si deux règles s'appliquent à une catégorie ou à un type, c'est la règle qui vient en dernier qui est appliquée.
Les règles peuvent être définies via la fonction ` 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 journalisation. Ces fichiers de configuration sont recherchés dans le répertoire de configuration QtProject, ou définis explicitement dans une variable d’environnement QT_LOGGING_CONF:
[Rules]
*.debug=false
driver.usb.debug=trueLes règles de journalisation peuvent également être spécifiées dans une variable d’environnement QT_LOGGING_RULES; plusieurs règles peuvent être séparées par des points-virgules :
QT_LOGGING_RULES=*.debug=false;driver.usb.debug=trueLes règles définies par setFilterRules() ont priorité sur celles spécifiées dans le répertoire de configuration QtProject. À leur tour, ces règles peuvent être remplacées par celles du fichier de configuration spécifié par QT_LOGGING_CONF, ainsi que par celles définies par QT_LOGGING_RULES.
L'ordre d'évaluation est le suivant :
- [QLibraryInfo::DataPath]/qtlogging.ini
- QtProject/qtlogging.ini
- setFilterRules()
QT_LOGGING_CONFQT_LOGGING_RULES
Le fichier QtProject/qtlogging.ini est recherché dans tous les répertoires renvoyés par QStandardPaths::GenericConfigLocation.
Définissez la variable d'environnement QT_LOGGING_DEBUG pour déterminer d'où proviennent vos règles de journalisation.
Installation d’un filtre personnalisé
Comme alternative de plus bas niveau aux règles de texte, vous pouvez également implémenter un filtre personnalisé via installFilter(). Dans ce cas, toutes les règles de filtrage sont ignorées.
Affichage de la catégorie
Utilisez l'espace réservé %{category} pour afficher la catégorie dans le gestionnaire de messages par défaut :
qSetMessagePattern("%{category} %{message}");Documentation sur les types de membres
QLoggingCategory::CategoryFilter
Il s'agit d'un typedef pour un pointeur vers une fonction ayant la signature suivante :
void myCategoryFilter(QLoggingCategory *);Une fonction présentant cette signature peut être installée à l'aide de ` installFilter()`.
Documentation sur les fonctions membres
[explicit] QLoggingCategory::QLoggingCategory(const char *category, QtMsgType enableForLevel = QtDebugMsg)
Crée un objet `QLoggingCategory` avec le nom d'category fourni, et active tous les messages dont le niveau de détail est au moins égal à ` enableForLevel`, dont la valeur par défaut est ` QtDebugMsg ` (ce qui active toutes les catégories).
Si category est égal à nullptr, le nom de catégorie "default" est utilisé.
Remarque : la variable category doit rester valide pendant toute la durée de vie de cet objet. Pour ce faire, on utilise généralement une chaîne littérale.
[noexcept] QLoggingCategory::~QLoggingCategory()
Supprime un objet de type « QLoggingCategory ».
const char *QLoggingCategory::categoryName() const
Renvoie le nom de la catégorie.
[static] QLoggingCategory *QLoggingCategory::defaultCategory()
Renvoie un pointeur vers l'"default" de catégorie globale utilisée, par exemple, par les fonctions qDebug(), qInfo(), qWarning(), qCritical() ou qFatal().
Remarque : le pointeur renvoyé peut être nul lors de la destruction d'objets statiques. De plus, ne pas « delete r » ce pointeur, car la propriété de la catégorie n'est pas transférée.
[static] QLoggingCategory::CategoryFilter QLoggingCategory::installFilter(QLoggingCategory::CategoryFilter filter)
Gérez la configuration des catégories de journalisation.
Installe une fonction filter qui sert à déterminer les catégories et les types de messages à activer. Si filter vaut nullptr, le filtre de messages par défaut est rétabli. Renvoie un pointeur vers le filtre précédemment installé.
Chaque objet ` QLoggingCategory ` déjà existant est transmis au filtre avant que ` installFilter() ` ne renvoie une valeur, 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é attribuée par le filtre précédent ; le nouveau filtre n’a donc pas besoin de déléguer au filtre précédent lors de ce premier passage sur les catégories existantes.
Toute nouvelle catégorie ajoutée par la suite sera transmise au nouveau filtre ; un filtre qui vise uniquement à ajuster la configuration de quelques catégories sélectionnées, plutôt que de remplacer complètement la politique de journalisation, peut d’abord transmettre la nouvelle catégorie au filtre précédent, afin de lui attribuer sa configuration standard, puis l’ajuster comme souhaité, s’il s’agit d’une des catégories présentant un intérêt particulier pour le filtre. Le code qui installe le nouveau filtre peut enregistrer la valeur renvoyée par ` installFilter() ` afin que le filtre puisse l’utiliser lors d’appels ultérieurs.
Lorsque vous définissez votre filtre, notez qu’il peut être appelé depuis différents threads, mais jamais simultanément. Ce filtre ne peut appeler aucune fonction statique 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 les 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 d'exécuter tout code. Cependant, l'appel de cette méthode peut s'avérer 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 les messages de débogage doivent s'afficher pour cette catégorie ; « false » dans le cas contraire.
Remarque : la macro qCDebug() effectue déjà cette vérification avant d'exécuter le moindre code. Cependant, l'appel de cette méthode peut s'avérer utile 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 » correspondant à la catégorie doit être affiché ; « false » dans le cas contraire.
bool QLoggingCategory::isInfoEnabled() const
Renvoie ` true ` si des messages d'information doivent s'afficher pour cette catégorie ; ` false ` dans le cas contraire.
Remarque : la macro qCInfo() effectue déjà cette vérification avant d'exécuter tout code. Cependant, l'appel de cette méthode peut s'avérer 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 s'afficher pour cette catégorie ; « false » dans le cas contraire.
Remarque : la macro qCWarning() effectue déjà cette vérification avant d'exécuter tout code. Cependant, l'appel de cette méthode peut s'avérer utile 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)
Modifie le type de message « type » de la catégorie en « enable ».
Cette méthode est destinée à être utilisée uniquement depuis un filtre installé avec installFilter(). Pour savoir comment configurer les catégories de manière globale, consultez Configuring Categories.
Remarque : QtFatalMsg ne peut pas être modifié ; il restera toujours true.
Voir également isEnabled().
[static] void QLoggingCategory::setFilterRules(const QString &rules)
Permet de définir les catégories et les types de messages à activer à l'aide d'un ensemble d'rules.
Exemple :
QLoggingCategory::setFilterRules(QStringLiteral("driver.usb.debug=true"));Remarque : les règles peuvent être ignorées si un filtre de catégorie personnalisé est installé via installFilter(), ou si l’utilisateur a défini les variables 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 de type ` QLoggingCategory ` et une méthode « factory » renvoyant un ` 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 de type ` QLoggingCategory ` et une méthode « factory » renvoyant un ` QLoggingCategory`, dans les macros ` qCDebug()`, ` qCWarning()`, ` qCCritical()` ou ` qCFatal()`.
Documentation des macros
[since 6.5] Q_DECLARE_EXPORTED_LOGGING_CATEGORY(name, EXPORT_MACRO)
Déclare une catégorie de journalisation name. Cette macro permet de déclarer une catégorie de journalisation commune, partagée entre différentes parties du programme.
Cela fonctionne exactement comme ` Q_DECLARE_LOGGING_CATEGORY()`. Cependant, la catégorie de journalisation déclarée par cette macro est en outre qualifiée par ` EXPORT_MACRO`. Cela s'avère utile si la catégorie de journalisation doit être exportée depuis une bibliothèque dynamique.
Par exemple :
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 également Q_LOGGING_CATEGORY() et Q_DECLARE_LOGGING_CATEGORY().
Q_DECLARE_LOGGING_CATEGORY(name)
Déclare une catégorie de journalisation name. Cette macro permet de 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 également 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 portant un nom spécifique. L'objet QLoggingCategory, défini implicitement, est créé lors de sa première utilisation, de manière sûre pour les threads.
Cette macro doit être utilisée en dehors d’une classe ou d’une méthode.
Voir également 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 niveau « QtMsgType », « msgType » et de gravité supérieure 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 portant un nom spécifique. L’objet QLoggingCategory, défini implicitement, est créé lors de sa première utilisation, de manière sûre pour les threads.
Cette macro doit être utilisée en dehors d’une classe ou d’une méthode.
Voir également 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 afin que vous ne puissiez y accéder que dans la même unité de traduction. Cela permet d’éviter les conflits de symboles accidentels.
L'objet QLoggingCategory défini implicitement est créé lors de sa première utilisation, de manière sûre pour les 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 niveau « QtMsgType », « msgType » et de gravité supérieure sont activés ; les messages de gravité inférieure sont désactivés.
La catégorie de journalisation est créée à l’aide du qualificateur static afin que vous ne puissiez y accéder que dans la même unité de traduction. Cela permet d’éviter les conflits de symboles accidentels.
L’objet QLoggingCategory, défini implicitement, est créé lors de sa première utilisation, de manière sûre pour les 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 de la catégorie de journalisation « category ».
La macro se développe en un code qui vérifie si ` QLoggingCategory::isCriticalEnabled()` renvoie ` true`. Si tel 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 ; ne comptez donc pas sur d'éventuels effets secondaires.
Voir également QDebug::qCritical().
qCCritical(category, const char *message, ...)
Enregistre un message critique, message, dans la catégorie de journalisation category. message peut contenir des espaces réservés destinés à être remplacés par des arguments supplémentaires, à l'instar de la fonction printf() en C.
Exemple :
QLoggingCategory category("driver.usb");
qCCritical(category, "a critical message logged into category %s", category.categoryName());Remarque : si la sortie « critique » pour une catégorie donnée n’est pas activée, les arguments ne seront pas traités ; ne comptez donc pas sur d’éventuels effets secondaires.
Voir également qCritical(const char *, ...).
qCDebug(category)
Renvoie un flux de sortie pour les messages de débogage de la catégorie de journalisation « category ».
La macro se développe en un code qui vérifie si la fonction ` QLoggingCategory::isDebugEnabled()` renvoie la valeur ` 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 ; ne comptez donc pas sur d'éventuels effets secondaires.
Voir aussi QDebug::qDebug().
qCDebug(category, const char *message, ...)
Enregistre un message de débogage, message, dans la catégorie de journalisation category. message peut contenir des espaces réservés destinés à être remplacés par des arguments supplémentaires, à l'instar de la fonction printf() en C.
Exemple :
QLoggingCategory category("driver.usb");
qCDebug(category, "a debug message logged into category %s", category.categoryName());Remarque : les arguments ne sont pas traités si la sortie de débogage pour ce category n'est pas activée ; ne comptez donc pas sur d'éventuels effets secondaires.
Voir également qDebug(const char *, ...).
[since 6.5] qCFatal(category)
Renvoie un flux de sortie pour les messages fatals de la catégorie de journalisation « category ».
Si vous utilisez le gestionnaire de messages par défaut, le flux renvoyé provoquera un arrêt forcé de l'application afin de créer un vidage de mémoire. Sous Windows, pour les versions de débogage, cette fonction signalera une erreur de type « _CRT_ERROR », ce qui vous permettra 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 également QDebug::qFatal().
[since 6.5] qCFatal(category, const char *message, ...)
Enregistre un message critique, message, dans la catégorie de journalisation category. message peut contenir des espaces réservés destinés à être remplacés par des arguments supplémentaires, à l'instar de la fonction printf() en 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 provoquera un arrêt forcé afin de créer un vidage de mémoire. Sous Windows, pour les versions de débogage, cette fonction signalera une « _CRT_ERROR » (erreur fatale), ce qui vous permettra de connecter un débogueur à l’application.
Cette macro a été introduite dans Qt 6.5.
Voir également qFatal(const char *, ...).
qCInfo(category)
Renvoie un flux de sortie pour les messages d'information de la catégorie de journalisation « category ».
La macro se développe en un code qui vérifie si la fonction ` QLoggingCategory::isInfoEnabled()` renvoie ` true`. Si tel 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 ; ne comptez donc pas sur d’éventuels effets secondaires.
Voir aussi QDebug::qInfo().
qCInfo(category, const char *message, ...)
Enregistre un message d'information, message, dans la catégorie de journalisation category. message peut contenir des espaces réservés destinés à être remplacés par des arguments supplémentaires, à l'instar de la fonction printf() du langage C.
Exemple :
QLoggingCategory category("driver.usb");
qCInfo(category, "an informational message logged into category %s", category.categoryName());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 ; ne comptez donc pas sur d'éventuels effets secondaires.
Voir également qInfo(const char *, ...).
qCWarning(category)
Renvoie un flux de sortie pour les messages d'avertissement de la catégorie de journalisation « category ».
La macro se développe en un code qui vérifie si QLoggingCategory::isWarningEnabled() donne 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 ; ne comptez donc pas sur d'éventuels effets secondaires.
Voir aussi QDebug::qWarning().
qCWarning(category, const char *message, ...)
Enregistre un message d'avertissement, message, dans la catégorie de journalisation category. La chaîne message peut contenir des espaces réservés destinés à être remplacés par des arguments supplémentaires, à l'instar de la fonction printf() du langage C.
Exemple :
QLoggingCategory category("driver.usb");
qCWarning(category, "a warning message logged into category %s", category.categoryName());Remarque : si la sortie d'avertissement pour une catégorie particulière n'est pas activée, les arguments ne seront pas traités ; ne comptez donc pas sur d'éventuels effets secondaires.
Voir également 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.