<QtLogging> - Qt Logging Types

Die Header-Datei <QtLogging> definiert Qt-Protokollierungstypen, -Funktionen und -Makros. Mehr...

Header: #include <QtLogging>

Typen

QtMessageHandler
enum QtMsgType { QtDebugMsg, QtInfoMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg }

Funktionen

QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str)
QtMessageHandler qInstallMessageHandler(QtMessageHandler handler)
void qSetMessagePattern(const QString &pattern)

Makros

qCritical(const char *format, ...)
qDebug(const char *format, ...)
qFatal(const char *format, ...)
qInfo(const char *format, ...)
qWarning(const char *format, ...)

Ausführliche Beschreibung

Die Header-Datei <QtLogging> enthält verschiedene Typen, Funktionen und Makros für die Protokollierung.

Die Enumeration ` QtMsgType ` identifiziert die verschiedenen Meldungen, die generiert und an einen Qt-Meldungshandler gesendet werden können; ` QtMessageHandler ` ist eine Typdefinition für einen Zeiger auf eine Funktion mit der Signatur ` void myMessageHandler(QtMsgType, const QMessageLogContext &, const char *)`. Mit der Funktion ` qInstallMessageHandler()` kann die angegebene ` QtMessageHandler` installiert werden. Die Klasse ` QMessageLogContext ` enthält die Zeile, die Datei und die Funktion, in der die Meldung protokolliert wurde. Diese Informationen werden von der Klasse ` QMessageLogger ` erstellt.

<QtLogging> enthält außerdem Funktionen, die Meldungen aus dem angegebenen String-Argument generieren: ` qDebug()`, ` qInfo()`, ` qWarning()`, ` qCritical()` und ` qFatal()`. Diese Funktionen rufen den Meldungshandler mit der angegebenen Meldung auf.

Beispiel:

if (!driver()->isOpen()|| driver()->isOpenError()) {
    qWarning("QSqlQuery::exec: database not open");
   return false;
}

Siehe auch QLoggingCategory.

Typdokumentation

QtMessageHandler

Dies ist ein `typedef` für einen Zeiger auf eine Funktion mit folgender Signatur:

void myMessageHandler(QtMsgType, const QMessageLogContext &, const QString &);

Siehe auch QtMsgType und qInstallMessageHandler().

enum QtMsgType

Diese Enumeration beschreibt die Meldungen, die an einen Meldungshandler gesendet werden können (QtMessageHandler). Sie können die Enumeration verwenden, um die verschiedenen Meldungstypen zu identifizieren und ihnen die entsprechenden Aktionen zuzuordnen. Ihre Werte sind, in der Reihenfolge steigender Schwere:

KonstanteWertBeschreibung
QtDebugMsg0Eine von der Funktion ` qDebug()` generierte Meldung.
QtInfoMsg4Eine von der Funktion ` qInfo()` generierte Meldung.
QtWarningMsg1Eine von der Funktion ` qWarning()` generierte Meldung.
QtCriticalMsg2Eine von der Funktion ` qCritical()` generierte Meldung.
QtFatalMsg3Eine von der Funktion „ qFatal()“ generierte Meldung.

Siehe auch „ QtMessageHandler“ , „ qInstallMessageHandler()“ und „ QLoggingCategory “.

Funktionsdokumentation

QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str)

Erzeugt aus den Argumenten „ type “, „ context “ und „ str “ eine formatierte Zeichenfolge.

`qFormatLogMessage` gibt eine ` QString ` zurück, die gemäß dem aktuellen Meldungsmuster formatiert ist. Sie kann von benutzerdefinierten Meldungshandlern verwendet werden, um die Ausgabe ähnlich wie beim Standard-Meldungshandler von Qt zu formatieren.

Die Funktion ist threadsicher.

Siehe auch ` qInstallMessageHandler()` und ` qSetMessagePattern()`.

QtMessageHandler qInstallMessageHandler(QtMessageHandler handler)

Installiert einen Qt XML-ph-0000@deepl.internal. Gibt einen Zeiger auf den zuvor installierten Meldungs handler zurück.

Ein Nachrichtenhandler ist eine Funktion, die Debug-, Info-, Warn-, kritische und schwerwiegende Meldungen aus der Protokollierungsinfrastruktur von Qt ausgibt. Standardmäßig verwendet Qt einen Standard-Nachrichtenhandler, der Meldungen formatiert und an verschiedene, vom Betriebssystem und der Qt-Konfiguration abhängige Ausgabekanäle ausgibt. Durch die Installation eines eigenen Nachrichtenhandlers erhalten Sie die volle Kontrolle und können beispielsweise Meldungen im Dateisystem protokollieren.

Beachten Sie, dass Qt „ logging categories “ unterstützt, um zusammengehörige Meldungen in semantischen Kategorien zu gruppieren. Sie können diese nutzen, um die Protokollierung pro Kategorie zu aktivieren oder zu deaktivieren ( message type). Da die Filterung nach Protokollierungskategorien bereits vor der Erstellung einer Meldung erfolgt, erreichen Meldungen für deaktivierte Typen und Kategorien den Meldungshandler nicht.

Ein Meldungshandler muss „ reentrant “ sein. Das heißt, er kann von verschiedenen Threads aus parallel aufgerufen werden. Daher müssen Schreibvorgänge in gemeinsame Senken (wie eine Datenbank oder eine Datei) oft synchronisiert werden.

Qt ermöglicht es, Protokollmeldungen durch den Aufruf von ` qSetMessagePattern()` oder durch Setzen der Umgebungsvariablen ` QT_MESSAGE_PATTERN ` mit weiteren Metainformationen anzureichern. Um diese Formatierung beizubehalten, kann ein benutzerdefinierter Nachrichtenhandler ` qFormatLogMessage()` verwenden.

Versuchen Sie, den Code im Meldungshandler selbst so minimal wie möglich zu halten, da ressourcenintensive Operationen die Anwendung blockieren könnten. Um Rekursion zu vermeiden, werden zudem alle im Meldungshandler selbst generierten Protokollmeldungen ignoriert.

Der Nachrichtenhandler sollte immer zurückkehren. Bei ` fatal messages` bricht die Anwendung unmittelbar nach der Bearbeitung dieser Nachricht ab.

Es kann jeweils nur ein Nachrichtenhandler für die gesamte Anwendung installiert sein. Falls zuvor bereits ein benutzerdefinierter Nachrichtenhandler installiert war, gibt die Funktion einen Zeiger darauf zurück. Dieser Handler kann dann später durch einen weiteren Aufruf der Methode erneut installiert werden. Durch den Aufruf von ` qInstallMessageHandler(nullptr) ` wird zudem der Standard-Nachrichtenhandler wiederhergestellt.

Hier ist ein Beispiel für einen Nachrichtenhandler, der vor dem Aufruf des Standardhandlers eine Protokollierung in eine lokale Datei vornimmt:

#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();
}

Beachten Sie, dass der C++-Standard garantiert, dass ` static FILE *f ` threadsicher initialisiert wird. Wir können auch davon ausgehen, dass ` fprintf() ` und ` fflush() ` threadsicher sind, sodass keine weitere Synchronisation erforderlich ist.

Siehe auch QtMessageHandler, QtMsgType, qDebug(), qInfo(), qWarning(), qCritical(), qFatal(), „Debugging-Techniken“ und qFormatLogMessage().

void qSetMessagePattern(const QString &pattern)

Ändert die Ausgabe des Standard-Meldungshandlers.

Ermöglicht die Anpassung der Ausgabe von qDebug(), qInfo(), qWarning(), qCritical() und qFatal(). Die Logging-Ausgabe der Kategorie von qCDebug(), qCInfo(), qCWarning() und qCCritical() wird ebenfalls formatiert.

Folgende Platzhalter werden unterstützt:

PlatzhalterBeschreibung
%{appname}QCoreApplication::applicationName()
%{category}Protokollierungskategorie
%{file}Pfad zur Quelldatei
%{function}Funktion
%{line}Zeile in der Quelldatei
%{message}Die eigentliche Meldung
%{pid}QCoreApplication::applicationPid()
%{threadid}Die systemweite ID des aktuellen Threads (sofern verfügbar)
%{threadname}Der Name des aktuellen Threads (sofern verfügbar; ab Qt 6.10 alternativ die Thread-ID)
%{qthreadptr}Ein Zeiger auf das aktuelle „ QThread “ (Ergebnis von ` QThread::currentThread()`)
%{type}„debug“, „warning“, „critical“ oder „fatal“
%{time process}Zeitpunkt der Meldung in Sekunden seit dem Start des Prozesses (das Token „process“ ist ein Literal)
%{time boot}Die Zeit der Meldung in Sekunden seit dem Systemstart, sofern diese ermittelt werden kann (das Token „boot“ ist ein Literal). Konnte die Zeit seit dem Systemstart nicht ermittelt werden, ist die Ausgabe unbestimmt (siehe QElapsedTimer::msecsSinceReference()).
%{time [format]}Systemzeit zum Zeitpunkt des Auftretens der Meldung, formatiert durch Übergabe von ` format ` an ` QDateTime::toString()`. Wenn kein Format angegeben wird, wird das Format von ` Qt::ISODate ` verwendet.
%{backtrace [depth=N] [separator="..."]}Ein Backtrace mit der durch den optionalen Parameter ` depth ` festgelegten Anzahl von Frames (Standardwert: 5), getrennt durch den optionalen Parameter ` separator ` (Standardwert: „|“). Ab Qt 6.12 ist die maximale Anzahl von Frames für ` depth ` auf 16384 begrenzt.

Diese Erweiterung ist nur auf einigen Plattformen verfügbar:

  • Plattformen, die glibc verwenden;
  • Plattformen, auf denen der C++23-Header ` <stacktrace> ` ausgeliefert wird (erfordert die Kompilierung von Qt im C++23-Modus).

Je nach Plattform gelten einige Einschränkungen hinsichtlich der von dieser Erweiterung ausgegebenen Funktionsnamen.

Auf einigen Plattformen sind nur die Namen der exportierten Funktionen bekannt. Wenn Sie den Namen jeder Funktion in Ihrer Anwendung sehen möchten, stellen Sie sicher, dass Ihre Anwendung mit ` -rdynamic` oder einem gleichwertigen Header kompiliert und verknüpft wird.

Beachten Sie beim Auswerten von Backtraces, dass aufgrund von Inlining oder Tail-Call-Optimierung möglicherweise Frames fehlen.

Sie können auch Bedingungen für den Typ der Meldung verwenden, indem Sie %{if-debug}, %{if-info}, %{if-warning}, %{if-critical} oder %{if-fatal} gefolgt von einem %{endif} einsetzen. Der Inhalt von %{if-*} und %{endif} wird nur ausgegeben, wenn der Typ übereinstimmt.

Schließlich wird der Text in %{if-category}... %{endif} nur ausgegeben, wenn die Kategorie nicht die Standardkategorie ist.

Beispiel:

    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}"

Der Standardwert für „ pattern “ lautet „ %{if-category}%{category}: %{endif}%{message} “.

Hinweis: Unter Android lautet das Standard-„ pattern “ %{message}, da die Kategorie als Tag verwendet wird, da Android Logcat über ein eigenes Feld für die Protokollierungskategorien verfügt (siehe Android-Protokollierung). Wenn ein benutzerdefiniertes „ pattern “ einschließlich der Kategorie verwendet wird, wird QCoreApplication::applicationName() als Tag verwendet.

Das pattern kann auch zur Laufzeit geändert werden, indem die Umgebungsvariable QT_MESSAGE_PATTERN gesetzt wird; wenn sowohl qSetMessagePattern() aufgerufen als auch QT_MESSAGE_PATTERN gesetzt wird, hat die Umgebungsvariable Vorrang.

Hinweis: Die Informationen zu den Platzhaltern ` category`, ` file`, ` function ` und ` line ` werden nur in Debug-Builds aufgezeichnet. Alternativ kann ` QT_MESSAGELOGCONTEXT ` explizit definiert werden. Weitere Informationen finden Sie in der Dokumentation unter QMessageLogContext.

Hinweis: Das Nachrichtenmuster gilt nur für unstrukturierte Protokollierung, wie beispielsweise die Standardausgabe von „ stderr “. Strukturierte Protokollierung wie bei systemd zeichnet die Nachricht unverändert auf, zusammen mit so vielen strukturierten Informationen, wie erfasst werden können.

Benutzerdefinierte Nachrichten-Handler können ` qFormatLogMessage()` verwenden, um ` pattern ` zu berücksichtigen.

Sicherheitshinweise

Qt entfernt keine Steuerzeichen aus ` pattern ` und führt auch keine Escape-Sequenzen durch – einschließlich der Bytes ` LF`, ` CR`, ` NUL ` sowie Terminal-Steuersequenzen. Das Akzeptieren eines Musters aus einer nicht vertrauenswürdigen Quelle ermöglicht daher das Fälschen von Protokollen oder das Senden von Steuersequenzen an den Empfänger des Protokollstroms. Darüber hinaus können bei einigen Protokollierungs-Backends Meldungen am Byte ` NUL ` (falls vorhanden) abgeschnitten werden.

Siehe auch „ qInstallMessageHandler()“, „Debugging Techniques“, „ QLoggingCategory “ und „ QMessageLogContext “.

Makro-Dokumentation

qCritical(const char *format, ...)

Protokolliert kritische Meldungen format an den zentralen Meldungshandler. format kann Formatangaben enthalten, die durch in zusätzlichen Argumenten angegebene Werte ersetzt werden.

Beispiel:

void load(const QString &fileName)
{
    QFile file(fileName);
    if (!file.exists())
        qCritical("File '%s' does not exist!", qUtf8Printable(fileName));
}

format kann Formatbezeichner wie %s für UTF-8-Zeichenketten oder %i für Ganzzahlen enthalten. Dies entspricht in etwa der Funktionsweise der C-Funktion ` printf() `. Weitere Details zur Formatierung finden Sie unter ` QString::asprintf()`.

Für mehr Komfort und eine umfassendere Typunterstützung können Sie auch QDebug::qCritical() verwenden, das dem Streaming-Paradigma folgt (ähnlich wie std::cout oder std::cerr).

Um die Ausgabe zur Laufzeit zu unterdrücken, können Sie logging rules definieren oder ein benutzerdefiniertes filter registrieren.

Zu Debugging-Zwecken ist es manchmal sinnvoll, das Programm bei kritischen Meldungen abbrechen zu lassen. So können Sie den Core-Dump untersuchen oder einen Debugger anhängen – siehe auch qFatal(). Um dies zu aktivieren, setzen Sie die Umgebungsvariable QT_FATAL_CRITICALS auf eine Zahl n. Das Programm wird dann bei der n-ten kritischen Meldung beendet. Das heißt, wenn die Umgebungsvariable auf 1 gesetzt ist, wird das Programm beim ersten Aufruf beendet; wenn sie den Wert 10 enthält, wird es beim 10. Aufruf beendet. Jeder nicht-numerische Wert in der Umgebungsvariable entspricht dem Wert 1.

Hinweis: Dieses Makro ist threadsicher.

Siehe auch QDebug::qCritical, qCCritical(), qDebug(), qInfo(), qWarning(), qFatal(), qInstallMessageHandler() sowie Debugging-Techniken.

qDebug(const char *format, ...)

Protokolliert die Debug-Meldung „ format “ im zentralen Meldungshandler. „ format “ kann Formatangaben enthalten, die durch in zusätzlichen Argumenten angegebene Werte ersetzt werden.

Beispiel:

qDebug("Items in list: %d", myList.size());

format kann Formatbezeichner wie %s für UTF-8-Zeichenketten oder %i für Ganzzahlen enthalten. Dies ähnelt der Funktionsweise der C-Funktion „ printf() “. Weitere Details zur Formatierung finden Sie unter QString::asprintf().

Für mehr Komfort und eine umfassendere Typunterstützung können Sie auch QDebug::qDebug() verwenden, das dem Streaming-Paradigma folgt (ähnlich wie std::cout oder std::cerr).

Diese Funktion führt keine Aktion aus, wenn QT_NO_DEBUG_OUTPUT während der Kompilierung definiert wurde.

Um die Ausgabe zur Laufzeit zu unterdrücken, implementieren Sie Ihren eigenen Meldungshandler mit qInstallMessageHandler().

Hinweis: Dieses Makro ist threadsicher.

Siehe auch QDebug::qDebug(), qCDebug(), qInfo(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler() und Debugging-Techniken.

qFatal(const char *format, ...)

Protokolliert die schwerwiegende Meldung „ format “ im zentralen Meldungshandler. „ format “ kann Formatangaben enthalten, die durch in zusätzlichen Argumenten angegebene Werte ersetzt werden.

Beispiel:

int divide_by_zero(int a, int b)
{
    if (b == 0)                                // program error
        qFatal("divide: cannot divide by zero");
    return a / b;
}

Wenn Sie den Standard-Meldungshandler verwenden, bricht diese Funktion ab, um einen Core-Dump zu erstellen. Unter Windows meldet diese Funktion bei Debug-Builds einen _CRT_ERROR, sodass Sie einen Debugger an die Anwendung anschließen können.

Um die Ausgabe zur Laufzeit zu unterdrücken, implementieren Sie Ihren eigenen Meldungshandler mit ` qInstallMessageHandler()`.

Siehe auch qCFatal(), qDebug(), qInfo(), qWarning(), qCritical(), qInstallMessageHandler() und Debugging-Techniken.

qInfo(const char *format, ...)

Protokolliert die Informationsmeldung „ format “ im zentralen Meldungshandler. „ format “ kann Formatangaben enthalten, die durch in zusätzlichen Argumenten angegebene Werte ersetzt werden.

Beispiel:

qInfo("Items in list: %d", myList.size());

format kann Formatbezeichner wie „ %s “ für UTF-8-Zeichenketten oder „ %i “ für Ganzzahlen enthalten. Dies entspricht in etwa der Funktionsweise der C-Funktion „ printf() “. Weitere Details zur Formatierung finden Sie unter „ QString::asprintf()“.

Für mehr Komfort und eine umfassendere Typunterstützung können Sie auch QDebug::qInfo() verwenden, das dem Streaming-Paradigma folgt (ähnlich wie std::cout oder std::cerr).

Diese Funktion führt keine Aktion aus, wenn QT_NO_INFO_OUTPUT während der Kompilierung definiert wurde.

Um die Ausgabe zur Laufzeit zu unterdrücken, implementieren Sie Ihren eigenen Meldungshandler mit qInstallMessageHandler().

Hinweis: Dieses Makro ist threadsicher.

Siehe auch QDebug::qInfo(), qCInfo(), qDebug(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler() und Debugging-Techniken.

qWarning(const char *format, ...)

Protokolliert die Warnmeldung „ format “ im zentralen Meldungshandler. „ format “ kann Formatangaben enthalten, die durch in zusätzlichen Argumenten angegebene Werte ersetzt werden.

Beispiel:

void f(int c)
{
    if (c > 200)
        qWarning("f: bad argument, c == %d", c);
}

format kann Formatbezeichner wie %s für UTF-8-Zeichenketten oder %i für Ganzzahlen enthalten. Dies ähnelt der Funktionsweise der C-Funktion „ printf() “. Weitere Details zur Formatierung finden Sie unter QString::asprintf().

Für mehr Komfort und eine umfassendere Typunterstützung können Sie auch QDebug::qWarning() verwenden, das dem Streaming-Paradigma folgt (ähnlich wie std::cout oder std::cerr).

Diese Funktion führt keine Aktion aus, wenn QT_NO_WARNING_OUTPUT bei der Kompilierung definiert wurde. Um die Ausgabe zur Laufzeit zu unterdrücken, können Sie logging rules setzen oder ein benutzerdefiniertes filter registrieren.

Zu Debugging-Zwecken ist es manchmal sinnvoll, das Programm bei Warnmeldungen abbrechen zu lassen. So können Sie den Core-Dump untersuchen oder einen Debugger anschließen – siehe auch qFatal(). Um dies zu aktivieren, setzen Sie die Umgebungsvariable QT_FATAL_WARNINGS auf eine Zahl n. Das Programm wird dann bei der n-ten Warnung beendet. Das heißt, wenn die Umgebungsvariable auf 1 gesetzt ist, wird das Programm beim ersten Aufruf beendet; wenn sie den Wert 10 enthält, wird es beim 10. Aufruf beendet. Jeder nicht-numerische Wert in der Umgebungsvariable entspricht dem Wert 1.

Hinweis: Dieses Makro ist threadsicher.

Siehe auch QDebug::qWarning(), qCWarning(), qDebug(), qInfo(), qCritical(), qFatal(), qInstallMessageHandler() und Debugging-Techniken.

© 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.