<QtLogging> - Qt Logging Types
Le fichier d'en-tête <QtLogging> définit les types, fonctions et macros de journalisation de Qt. Plus d'informations...
| Header: | #include <QtLogging> |
Types
| QtMessageHandler | |
| enum | QtMsgType { QtDebugMsg, QtInfoMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg } |
Fonctions
| QString | qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str) |
| QtMessageHandler | qInstallMessageHandler(QtMessageHandler handler) |
| void | qSetMessagePattern(const QString &pattern) |
Macros
| qCritical(const char *format, ...) | |
| qDebug(const char *format, ...) | |
| qFatal(const char *format, ...) | |
| qInfo(const char *format, ...) | |
| qWarning(const char *format, ...) |
Description détaillée
Le fichier d'en-tête <QtLogging> contient plusieurs types, fonctions et macros pour la journalisation.
L'enum QtMsgType identifie les différents messages qui peuvent être générés et envoyés à un gestionnaire de messages Qt ; QtMessageHandler est une définition de type pour un pointeur vers une fonction avec la signature void myMessageHandler(QtMsgType, const QMessageLogContext &, const char *). qInstallMessageHandler La fonction () peut être utilisée pour installer la classe QtMessageHandler. QMessageLogContext contient la ligne, le fichier et la fonction où le message a été enregistré. Ces informations sont créées par la classe QMessageLogger.
<QtLogging> contient également des fonctions qui génèrent des messages à partir de la chaîne de caractères donnée en argument : qDebug(), qInfo(), qWarning(), qCritical() et qFatal(). Ces fonctions appellent le gestionnaire de messages avec le message donné.
Exemple :
if (!driver()->isOpen() || driver()->isOpenError()) { qWarning("QSqlQuery::exec: database not open"); return false; }
Voir aussi QLoggingCategory.
Documentation sur les types
QtMessageHandler
Il s'agit d'un typedef pour un pointeur sur une fonction avec la signature suivante :
void myMessageHandler(QtMsgType, const QMessageLogContext &, const QString &);
Voir aussi QtMsgType et qInstallMessageHandler().
enum QtMsgType
Cette énumération décrit les messages qui peuvent être envoyés à un gestionnaire de messages (QtMessageHandler). Vous pouvez utiliser cette liste pour identifier et associer les différents types de messages aux actions appropriées. Ses valeurs sont, par ordre croissant de gravité, les suivantes
| Constante | Valeur | Description |
|---|---|---|
QtDebugMsg | 0 | Message généré par la fonction qDebug(). |
QtInfoMsg | 4 | Message généré par la fonction qInfo(). |
QtWarningMsg | 1 | Un message généré par la fonction qWarning(). |
QtCriticalMsg | 2 | Un message généré par la fonction qCritical(). |
QtFatalMsg | 3 | Un message généré par la fonction qFatal(). |
Voir aussi QtMessageHandler, qInstallMessageHandler(), et QLoggingCategory.
Documentation des fonctions
QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str)
Génère une chaîne formatée à partir des arguments type, context, str.
qFormatLogMessage renvoie une adresse QString formatée selon le modèle de message actuel. Elle peut être utilisée par des gestionnaires de messages personnalisés pour formater la sortie de manière similaire au gestionnaire de messages par défaut de Qt.
Cette fonction est à l'épreuve des threads.
Voir aussi qInstallMessageHandler() et qSetMessagePattern().
QtMessageHandler qInstallMessageHandler(QtMessageHandler handler)
Installe un message Qt handler. Renvoie un pointeur vers le gestionnaire de messages précédemment installé.
Un gestionnaire de messages est une fonction qui imprime des messages de débogage, d'information, d'avertissement, critiques et fatals à partir de l'infrastructure de journalisation de Qt. Par défaut, Qt utilise un gestionnaire de messages standard qui formate et imprime les messages vers différents puits spécifiques au système d'exploitation et à la configuration de Qt. L'installation de votre propre gestionnaire de messages vous permet de prendre le contrôle total et, par exemple, de consigner les messages dans le système de fichiers.
Notez que Qt prend en charge logging categories pour regrouper les messages apparentés dans des catégories sémantiques. Vous pouvez les utiliser pour activer ou désactiver la journalisation par catégorie et message type. Comme le filtrage des catégories de journalisation est effectué avant même la création d'un message, les messages pour les types et catégories désactivés n'atteindront pas le gestionnaire de messages.
Un gestionnaire de messages doit être reentrant. En d'autres termes, il peut être appelé à partir de différents threads, en parallèle. Par conséquent, les écritures dans des puits communs (comme une base de données ou un fichier) doivent souvent être synchronisées.
Qt XML permet d'enrichir les messages de journalisation avec des méta-informations supplémentaires en appelant qSetMessagePattern(), ou en définissant la variable d'environnement QT_MESSAGE_PATTERN. Pour conserver ce formatage, un gestionnaire de message personnalisé peut utiliser qFormatLogMessage().
Essayez de minimiser le code dans le gestionnaire de messages lui-même, car des opérations coûteuses pourraient bloquer l'application. De plus, pour éviter la récursivité, tout message de journalisation généré dans le gestionnaire de messages lui-même sera ignoré.
Le gestionnaire de messages doit toujours renvoyer. Pour fatal messages, l'application s'arrête immédiatement après avoir traité ce message.
Un seul gestionnaire de messages peut être installé à la fois, pour l'ensemble de l'application. Si un gestionnaire de messages personnalisé a déjà été installé, la fonction renvoie un pointeur vers celui-ci. Ce gestionnaire peut être réinstallé ultérieurement par un autre appel à la méthode. De même, l'appel à qInstallMessageHandler(nullptr) rétablira le gestionnaire de messages par défaut.
Voici un exemple de gestionnaire de messages qui se connecte à un fichier local avant d'appeler le gestionnaire par défaut :
#include <QApplication> #include <stdio.h> #include <stdlib.h> QtMessageHandler originalHandler = nullptr; void logToFile(QtMsgType type, const QMessageLogContext &context, const QString &msg) { QString message = qFormatLogMessage(type, context, msg); static FILE *f = fopen("log.txt", "a"); fprintf(f, "%s\n", qPrintable(message)); fflush(f); if (originalHandler) originalHandler(type, context, msg); } int main(int argc, char **argv) { originalHandler = qInstallMessageHandler(logToFile); QApplication app(argc, argv); // ... return app.exec(); }
Notez que la norme C++ garantit que static FILE *f est initialisé de manière sûre pour les threads. Nous pouvons également nous attendre à ce que fprintf() et fflush() soient à l'abri des threads, de sorte qu'aucune synchronisation supplémentaire n'est nécessaire.
Voir également QtMessageHandler, QtMsgType, qDebug(), qInfo(), qWarning(), qCritical(), qFatal(), Techniques de débogage, et qFormatLogMessage().
void qSetMessagePattern(const QString &pattern)
Modifie la sortie du gestionnaire de messages par défaut.
Permet de modifier la sortie de qDebug(), qInfo(), qWarning(), qCritical(), et qFatal(). La sortie de l'enregistrement des catégories de qCDebug(), qCInfo(), qCWarning(), et qCCritical() est également formatée.
Les caractères génériques suivants sont pris en charge :
| Caractère générique | Description |
|---|---|
%{appname} | QCoreApplication::applicationName() |
%{category} | Catégorie de journalisation |
%{file} | Chemin d'accès au fichier source |
%{function} | Fonction |
%{line} | Ligne du fichier source |
%{message} | Le message actuel |
%{pid} | QCoreApplication::applicationPid() |
%{threadid} | L'ID système du thread actuel (s'il peut être obtenu) |
%{threadname} | Le nom du thread actuel (s'il peut être obtenu, ou l'ID du thread, depuis Qt 6.10) |
%{qthreadptr} | Un pointeur sur le site QThread (résultat de QThread::currentThread()) |
%{type} | "debug", "warning", "critical" ou "fatal" |
%{time process} | l'heure du message, en secondes depuis le début du processus (le jeton "process" est littéral) |
%{time boot} | l'heure du message, en secondes, depuis le démarrage du système si cela peut être déterminé (le jeton "boot" est littéral). Si l'heure de démarrage n'a pas pu être obtenue, la sortie est indéterminée (voir QElapsedTimer::msecsSinceReference()). |
%{time [format]} | l'heure du système à laquelle le message s'est produit, formatée en passant l'adresse format à QDateTime::toString(). Si le format n'est pas spécifié, le format de Qt::ISODate est utilisé. |
%{backtrace [depth=N] [separator="..."]} | Une trace rétrospective avec le nombre de trames spécifié par le paramètre optionnel depth (5 par défaut), et séparée par le paramètre optionnel separator ("|" par défaut).Cette extension n'est disponible que sur certaines plateformes :
Selon la plate-forme, il existe des restrictions sur les noms de fonctions imprimés par cette extension. Sur certaines plateformes, les noms ne sont connus que pour les fonctions exportées. Si vous voulez voir le nom de chaque fonction dans votre application, assurez-vous que votre application est compilée et liée avec Lors de la lecture des backtraces, tenez compte du fait que des cadres peuvent être manquants en raison de l'inlining ou de l'optimisation des appels de queue. |
Vous pouvez également utiliser des conditionnelles sur le type du message en utilisant %{if-debug}, %{if-info} %{if-warning} , %{if-critical} ou %{if-fatal} suivi d'un %{endif}. Ce qui se trouve à l'intérieur des %{if-*} et %{endif} ne sera imprimé que si le type correspond.
Enfin, le texte contenu dans %{if-category}... %{endif} n'est imprimé que si la catégorie n'est pas celle par défaut.
Exemple :
QT_MESSAGE_PATTERN="[%{time yyyyMMdd h:mm:ss.zzz ttt} %{if-debug}D%{endif}%{if-info}I%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-fatal}F%{endif}] %{file}:%{line} - %{message}"
La catégorie par défaut pattern est %{if-category}%{category}: %{endif}%{message}.
Note : Sur Android, le pattern par défaut est %{message} parce que la catégorie est utilisée comme balise depuis que Android logcat a un champ dédié pour les catégories de journalisation, voir Android Logging. Si un pattern personnalisé incluant la catégorie est utilisé, QCoreApplication::applicationName() est utilisé comme balise.
L'adresse pattern peut également être modifiée à l'exécution en définissant la variable d'environnement QT_MESSAGE_PATTERN ; si qSetMessagePattern() est appelé et que QT_MESSAGE_PATTERN est défini, la variable d'environnement est prioritaire.
Remarque : les informations relatives aux espaces réservés category, file, function et line ne sont enregistrées que dans les versions de débogage. Il est également possible de définir explicitement QT_MESSAGELOGCONTEXT. Pour plus d'informations, consultez la documentation de QMessageLogContext.
Remarque : le modèle de message ne s'applique qu'à la journalisation non structurée, telle que la sortie par défaut de stderr. La journalisation structurée telle que systemd enregistre le message tel quel, avec autant d'informations structurées qu'il est possible de capturer.
Les gestionnaires de messages personnalisés peuvent utiliser qFormatLogMessage() pour prendre en compte pattern.
Voir aussi qInstallMessageHandler(), Techniques de débogage, QLoggingCategory, et QMessageLogContext.
Documentation sur les macros
qCritical(const char *format, ...)
Enregistre le message critique format dans le gestionnaire de messages central. format peut contenir des spécificateurs de format qui sont remplacés par des valeurs spécifiées dans des arguments supplémentaires.
Exemple :
void load(const QString &fileName) { QFile file(fileName); if (!file.exists()) qCritical("File '%s' does not exist!", qUtf8Printable(fileName)); }
format peut contenir des spécificateurs de format tels que %s pour les chaînes UTF-8 ou %i pour les entiers. Le fonctionnement est similaire à celui de la fonction C printf(). Pour plus de détails sur le formatage, voir QString::asprintf().
Pour plus de commodité et une meilleure prise en charge des types, vous pouvez également utiliser QDebug::qCritical(), qui suit le paradigme du flux (similaire à std::cout ou std::cerr).
Pour supprimer la sortie au moment de l'exécution, vous pouvez définir logging rules ou enregistrer un filter personnalisé.
À des fins de débogage, il est parfois pratique de laisser le programme s'interrompre en cas de messages critiques. Cela vous permet d'inspecter le vidage du noyau, ou d'attacher un débogueur - voir aussi qFatal(). Pour ce faire, définissez la variable d'environnement QT_FATAL_CRITICALS avec un nombre n. Le programme se termine alors pour le n-ième message critique. En d'autres termes, si la variable d'environnement a la valeur 1, le programme se terminera au premier appel ; si elle contient la valeur 10, il se terminera au dixième appel. Toute valeur non numérique dans la variable d'environnement est équivalente à 1.
Remarque : cette macro est à l'épreuve des threads.
Voir aussi QDebug::qCritical, qCCritical(), qDebug(), qInfo(), qWarning(), qFatal(), qInstallMessageHandler(), et Techniques de débogage.
qDebug(const char *format, ...)
Enregistre le message de débogage format dans le gestionnaire de messages central. format peut contenir des spécificateurs de format qui sont remplacés par des valeurs spécifiées dans des arguments supplémentaires.
Exemple :
qDebug("Items in list: %d", myList.size());
format peut contenir des spécificateurs de format tels que %s pour les chaînes UTF-8 ou %i pour les entiers. Le fonctionnement est similaire à celui de la fonction C printf(). Pour plus de détails sur le formatage, voir QString::asprintf().
Pour plus de commodité et une meilleure prise en charge des types, vous pouvez également utiliser QDebug::qDebug(), qui suit le paradigme du flux (similaire à std::cout ou std::cerr).
Cette fonction ne fait rien si QT_NO_DEBUG_OUTPUT a été défini lors de la compilation.
Pour supprimer la sortie au moment de l'exécution, installez votre propre gestionnaire de messages avec qInstallMessageHandler().
Remarque : cette macro est à l'épreuve des threads.
Voir aussi QDebug::qDebug(), qCDebug(), qInfo(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler(), et Techniques de débogage.
qFatal(const char *format, ...)
Enregistre le message fatal format dans le gestionnaire de messages central. format peut contenir des spécificateurs de format qui sont remplacés par des valeurs spécifiées dans des arguments supplémentaires.
Exemple :
int divide_by_zero(int a, int b) { if (b == 0) // program error qFatal("divide: cannot divide by zero"); return a / b; }
Si vous utilisez le gestionnaire de messages par défaut, cette fonction abandonnera la création d'un core dump. Sous Windows, pour les versions de débogage, cette fonction signalera un _CRT_ERROR vous permettant de connecter un débogueur à l'application.
Pour supprimer la sortie au moment de l'exécution, installez votre propre gestionnaire de messages avec qInstallMessageHandler().
Voir aussi qCFatal(), qDebug(), qInfo(), qWarning(), qCritical(), qInstallMessageHandler(), et Techniques de débogage.
qInfo(const char *format, ...)
Enregistre le message d'information format dans le gestionnaire de messages central. format peut contenir des spécificateurs de format qui sont remplacés par des valeurs spécifiées dans des arguments supplémentaires.
Exemple :
qInfo("Items in list: %d", myList.size());
format peut contenir des spécificateurs de format tels que %s pour les chaînes UTF-8 ou %i pour les entiers. Le fonctionnement est similaire à celui de la fonction C printf(). Pour plus de détails sur le formatage, voir QString::asprintf().
Pour plus de commodité et une meilleure prise en charge des types, vous pouvez également utiliser QDebug::qInfo(), qui suit le paradigme du flux (similaire à std::cout ou std::cerr).
Cette fonction ne fait rien si QT_NO_INFO_OUTPUT a été défini lors de la compilation.
Pour supprimer la sortie au moment de l'exécution, installez votre propre gestionnaire de messages à l'aide de qInstallMessageHandler().
Remarque : cette macro est à l'épreuve des threads.
Voir aussi QDebug::qInfo(), qCInfo(), qDebug(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler(), et Techniques de débogage.
qWarning(const char *format, ...)
Enregistre le message d'avertissement format dans le gestionnaire central de messages. format peut contenir des spécificateurs de format qui sont remplacés par des valeurs spécifiées dans des arguments supplémentaires.
Exemple :
void f(int c) { if (c > 200) qWarning("f: bad argument, c == %d", c); }
format peut contenir des spécificateurs de format tels que %s pour les chaînes UTF-8 ou %i pour les entiers. Le fonctionnement est similaire à celui de la fonction C printf(). Pour plus de détails sur le formatage, voir QString::asprintf().
Pour plus de commodité et une meilleure prise en charge des types, vous pouvez également utiliser QDebug::qWarning(), qui suit le paradigme du flux (similaire à std::cout ou std::cerr).
Cette fonction ne fait rien si QT_NO_WARNING_OUTPUT a été défini lors de la compilation. Pour supprimer la sortie au moment de l'exécution, vous pouvez définir logging rules ou enregistrer un filter personnalisé.
À des fins de débogage, il est parfois pratique de laisser le programme s'interrompre en cas de messages d'avertissement. Cela vous permet d'inspecter le core dump, ou d'attacher un débogueur - voir aussi qFatal(). Pour ce faire, définissez la variable d'environnement QT_FATAL_WARNINGS avec un nombre n. Le programme se termine alors pour le n-ième avertissement. En d'autres termes, si la variable d'environnement a la valeur 1, le programme se terminera au premier appel ; si elle contient la valeur 10, il se terminera au dixième appel. Toute valeur non numérique dans la variable d'environnement est équivalente à 1.
Remarque : cette macro est à l'épreuve des threads.
Voir aussi QDebug::qWarning(), qCWarning(), qDebug(), qInfo(), qCritical(), qFatal(), qInstallMessageHandler(), et Techniques de débogage.
© 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.