<QtLogging> - Qt Logging Types

Die <QtLogging> Header Datei definiert Qt Logging Typen, 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 *message, ...)
qDebug(const char *message, ...)
qFatal(const char *message, ...)
qInfo(const char *message, ...)
qWarning(const char *message, ...)

Detaillierte Beschreibung

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

Das QtMsgType enum identifiziert die verschiedenen Nachrichten, die erzeugt und an einen Qt message handler 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 *). qInstallMessageHandler() Funktion kann verwendet werden, um die angegebene QtMessageHandler zu installieren. QMessageLogContext Klasse enthält die Zeile, Datei und Funktion, in der die Nachricht protokolliert wurde. Diese Informationen werden von der Klasse QMessageLogger erstellt.

<QtLogging> enthält auch Funktionen, die Nachrichten aus dem angegebenen String-Argument erzeugen: qDebug(), qInfo(), qWarning(), qCritical() und qFatal(). Diese Funktionen rufen den Message-Handler mit der gegebenen Nachricht auf.

Beispiel:

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

Siehe auch QLoggingCategory.

Typ-Dokumentation

QtMessageHandler

Dies ist ein Typedef für einen Zeiger auf eine Funktion mit der folgenden Signatur:

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

Siehe auch QtMsgType und qInstallMessageHandler().

enum QtMsgType

Diese Aufzählung beschreibt die Nachrichten, die an einen Message Handler (QtMessageHandler) gesendet werden können. Sie können die Aufzählung verwenden, um die verschiedenen Nachrichtentypen zu identifizieren und mit den entsprechenden Aktionen zu verknüpfen. Die Werte sind, in der Reihenfolge des zunehmenden Schweregrads:

KonstanteWertBeschreibung
QtDebugMsg0Eine Nachricht, die von der Funktion qDebug() erzeugt wurde.
QtInfoMsg4Eine Meldung, die von der Funktion qInfo() erzeugt wurde.
QtWarningMsg1Eine Nachricht, die von der Funktion qWarning() erzeugt wird.
QtCriticalMsg2Eine Nachricht, die von der Funktion qCritical() erzeugt wurde.
QtFatalMsg3Eine Nachricht, die von der Funktion qFatal() erzeugt wurde.

Siehe auch QtMessageHandler, qInstallMessageHandler(), und QLoggingCategory.

Funktionsdokumentation

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

Erzeugt eine formatierte Zeichenkette aus den Argumenten type, context, str.

qFormatLogMessage gibt eine QString zurück, die gemäß dem aktuellen Nachrichtenmuster formatiert ist. Sie kann von benutzerdefinierten Message-Handlern verwendet werden, um die Ausgabe ähnlich wie der Standard Message-Handler von Qt zu formatieren.

Die Funktion ist thread-sicher.

Siehe auch qInstallMessageHandler() und qSetMessagePattern().

QtMessageHandler qInstallMessageHandler(QtMessageHandler handler)

Installiert eine Qt-Nachricht handler. Gibt einen Zeiger auf den zuvor installierten Message-Handler zurück.

Ein Message-Handler ist eine Funktion, die Debug-, Info-, Warn-, Critical- und Fatal-Meldungen aus der Logging-Infrastruktur von Qt ausgibt. Standardmäßig verwendet Qt einen Standard Message Handler, der Nachrichten formatiert und an verschiedene Senken ausgibt, die für das Betriebssystem und die Qt-Konfiguration spezifisch sind. Die Installation eines eigenen Message-Handlers erlaubt es Ihnen, die volle Kontrolle zu übernehmen und z.B. Nachrichten in das Dateisystem zu protokollieren.

Beachten Sie, dass Qt logging categories unterstützt, um verwandte Nachrichten in semantischen Kategorien zu gruppieren. Sie können diese verwenden, um die Protokollierung pro Kategorie und message type zu aktivieren oder zu deaktivieren. Da die Filterung nach Logging-Kategorien bereits vor der Erstellung einer Nachricht erfolgt, werden Nachrichten für deaktivierte Typen und Kategorien den Message-Handler nicht erreichen.

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 erlaubt es, Logging-Nachrichten mit weiteren Meta-Informationen anzureichern, indem man qSetMessagePattern() aufruft, oder die Umgebungsvariable QT_MESSAGE_PATTERN setzt. Um diese Formatierung beizubehalten, kann ein benutzerdefinierter Nachrichten-Handler qFormatLogMessage() verwenden.

Versuchen Sie, den Code im Message-Handler selbst minimal zu halten, da teure Operationen die Anwendung blockieren könnten. Um Rekursionen zu vermeiden, werden außerdem alle Protokollierungsmeldungen, die im Message-Handler selbst erzeugt werden, ignoriert.

Der Message-Handler sollte immer zurückkehren. Bei fatal messages bricht die Anwendung sofort nach der Bearbeitung dieser Nachricht ab.

Es kann jeweils nur ein Message-Handler für die gesamte Anwendung installiert werden. Wenn bereits ein benutzerdefinierter Message-Handler installiert war, gibt die Funktion einen Zeiger auf diesen zurück. Dieser Handler kann dann später durch einen weiteren Aufruf der Methode wieder installiert werden. Außerdem wird durch den Aufruf von qInstallMessageHandler(nullptr) der Standard-Nachrichten-Handler wiederhergestellt.

Hier ist ein Beispiel für einen Message-Handler, der in eine lokale Datei protokolliert, bevor er den Standard-Handler aufruft:

#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 auf eine thread-sichere Weise initialisiert wird. Wir können auch davon ausgehen, dass fprintf() und fflush() thread-sicher sind, so dass 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 Message Handlers.

Ermöglicht es, die Ausgabe von qDebug(), qInfo(), qWarning(), qCritical() und qFatal() zu optimieren. Die Ausgabe der Kategorieprotokollierung von qCDebug(), qCInfo(), qCWarning() und qCCritical() wird ebenfalls formatiert.

Die folgenden Platzhalter werden unterstützt:

PlatzhalterBeschreibung
%{appname}QCoreApplication::applicationName()
%{category}Kategorie der Protokollierung
%{file}Pfad zur Quelldatei
%{function}Funktion
%{line}Zeile in der Quelldatei
%{message}Die eigentliche Nachricht
%{pid}QCoreApplication::applicationPid()
%{threadid}Die systemweite ID des aktuellen Threads (falls sie ermittelt werden kann)
%{qthreadptr}Ein Zeiger auf den aktuellen QThread (Ergebnis von QThread::currentThread())
%{type}"debug", "warning", "critical" oder "fatal"
%{time process}Zeit der Meldung in Sekunden seit Beginn des Prozesses (das Token "process" ist ein Literal)
%{time boot}die Zeit der Meldung in Sekunden seit dem Systemstart, sofern dieser ermittelt werden kann (das Token "boot" ist ein Literal). Wenn die Zeit seit dem Systemstart nicht ermittelt werden konnte, ist die Ausgabe unbestimmt (siehe QElapsedTimer::msecsSinceReference()).
%{time [format]}die Systemzeit, zu der die Meldung auftrat, formatiert durch Übergabe von format an QDateTime::toString(). Wenn das Format nicht angegeben wird, wird das Format von Qt::ISODate verwendet.
%{backtrace [depth=N] [separator="..."]}Ein Backtrace mit der Anzahl der Frames, die durch den optionalen Parameter depth (Standardwert: 5) angegeben und durch den optionalen Parameter separator (Standardwert: "|") getrennt wird.

Diese Erweiterung ist nur auf einigen Plattformen verfügbar:

  • Plattformen, die glibc verwenden;
  • Plattformen, die den <stacktrace> -Header von C++23 verwenden (erfordert die Kompilierung von Qt im C++23-Modus).

Je nach Plattform gibt es einige Einschränkungen für die Funktionsnamen, die von dieser Erweiterung ausgegeben werden.

Auf einigen Plattformen sind die Namen nur für exportierte Funktionen bekannt. Wenn Sie den Namen jeder Funktion in Ihrer Anwendung sehen wollen, stellen Sie sicher, dass Ihre Anwendung mit -rdynamic kompiliert und gelinkt ist.

Berücksichtigen Sie beim Lesen von Backtraces, dass Frames aufgrund von Inlining oder Tail-Call-Optimierung fehlen könnten.

Sie können auch Bedingungen an den Typ der Nachricht stellen, indem Sie %{if-debug}, %{if-info} %{if-warning} , %{if-critical} oder %{if-fatal} gefolgt von %{endif} verwenden. Was in %{if-*} und %{endif} steht, wird nur gedruckt, wenn der Typ übereinstimmt.

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

Beispiel:

    QT_MESSAGE_PATTERN="[%{time yyyyMMdd h:mm:ss.zzz t} %{if-debug}D%{endif}%{if-info}I%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-fatal}F%{endif}] %{file}:%{line} - %{message}"

Die Standardkategorie pattern ist %{if-category}%{category}: %{endif}%{message}.

Hinweis: Unter Android ist die Standardvorgabe pattern %{message} , da die Kategorie als Tag verwendet wird, da Android logcat ein eigenes Feld für die Logging-Kategorien hat, siehe Android Logging. Wenn eine benutzerdefinierte pattern einschließlich der Kategorie verwendet wird, wird QCoreApplication::applicationName() als Tag verwendet.

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

Hinweis: Die Informationen für die Platzhalter category, file, function und line werden nur in Debug-Builds aufgezeichnet. Alternativ dazu kann QT_MESSAGELOGCONTEXT explizit definiert werden. Weitere Informationen finden Sie in der Dokumentation QMessageLogContext.

Hinweis: Das Meldungsmuster gilt nur für die unstrukturierte Protokollierung, wie die Standardausgabe stderr. Strukturierte Protokollierung wie systemd zeichnet die Nachricht so auf, wie sie ist, zusammen mit so vielen strukturierten Informationen, wie erfasst werden können.

Benutzerdefinierte Nachrichtenhandler können qFormatLogMessage() verwenden, um pattern zu berücksichtigen.

Siehe auch qInstallMessageHandler(), Debugging-Techniken, QLoggingCategory, und QMessageLogContext.

Makro-Dokumentation

qCritical(const char *message, ...)

Ruft den Message-Handler mit der kritischen Meldung message auf. Wenn kein Message-Handler installiert ist, wird die Meldung in stderr ausgegeben. Unter Windows wird die Nachricht an den Debugger gesendet. Unter QNX wird die Nachricht an slogger2 gesendet.

Diese Funktion nimmt eine Formatzeichenkette und eine Liste von Argumenten entgegen, ähnlich wie die C-Funktion printf(). Das Format sollte eine Latin-1 Zeichenkette sein.

Beispiel:

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

Wenn Sie <QtDebug> einschließen, ist auch eine bequemere Syntax verfügbar:

qCritical() << "Brush:" << myQBrush << "Other value:" << i;

Zwischen den Elementen wird ein Leerzeichen eingefügt, und am Ende wird ein Zeilenumbruch angehängt.

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

Zu Debugging-Zwecken ist es manchmal praktisch, das Programm bei kritischen Meldungen abbrechen zu lassen. Dadurch können Sie den Kernspeicherauszug untersuchen oder einen Debugger anschließen - siehe auch qFatal(). Um dies zu ermöglichen, setzen Sie die Umgebungsvariable QT_FATAL_CRITICALS auf eine Zahl n. Das Programm bricht dann bei der n-ten kritischen Meldung ab. Das heißt, wenn die Umgebungsvariable auf 1 gesetzt ist, wird es beim ersten Aufruf beendet; wenn sie den Wert 10 enthält, wird es beim zehnten Aufruf beendet. Jeder nicht-numerische Wert in der Umgebungsvariablen ist gleichbedeutend mit 1.

Hinweis: Dieses Makro ist thread-sicher.

Siehe auch qCCritical(), qDebug(), qInfo(), qWarning(), qFatal(), qInstallMessageHandler(), und Debugging-Techniken.

qDebug(const char *message, ...)

Ruft den Message-Handler mit der Debug-Meldung message auf. Wenn kein Message-Handler installiert wurde, wird die Nachricht in stderr ausgegeben. Unter Windows wird die Nachricht an die Konsole gesendet, wenn es sich um eine Konsolenanwendung handelt; andernfalls wird sie an den Debugger gesendet. Unter QNX wird die Nachricht an slogger2 gesendet. Diese Funktion tut nichts, wenn QT_NO_DEBUG_OUTPUT während der Kompilierung definiert wurde.

Wenn Sie der Funktion eine Formatzeichenkette und eine Liste von Argumenten übergeben, arbeitet sie ähnlich wie die C-Funktion printf(). Das Format sollte eine Latin-1 Zeichenkette sein.

Beispiel:

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

Wenn Sie <QtDebug> einbinden, ist auch eine bequemere Syntax verfügbar:

qDebug() << "Brush:" << myQBrush << "Other value:" << i;

Mit dieser Syntax gibt die Funktion ein QDebug Objekt zurück, das für die Verwendung des QtDebugMsg Nachrichtentyps konfiguriert ist. Sie setzt automatisch ein einzelnes Leerzeichen zwischen die einzelnen Elemente und gibt am Ende einen Zeilenumbruch aus. Sie unterstützt viele C++- und Qt-Typen.

Um die Ausgabe zur Laufzeit zu unterdrücken, installieren Sie Ihren eigenen Message-Handler mit qInstallMessageHandler().

Hinweis: Dieses Makro ist thread-sicher.

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

qFatal(const char *message, ...)

Ruft den Message-Handler mit der fatalen Meldung message auf. Wenn kein Message-Handler installiert ist, wird die Meldung in stderr ausgegeben. Unter Windows wird die Nachricht an den Debugger gesendet. Unter QNX wird die Nachricht an slogger2 gesendet.

Wenn Sie den Standard Message Handler verwenden, bricht diese Funktion ab, um einen Core Dump zu erstellen. Unter Windows, für Debug-Builds, meldet diese Funktion einen _CRT_ERROR, der es Ihnen ermöglicht, einen Debugger mit der Anwendung zu verbinden.

Diese Funktion nimmt einen Format-String und eine Liste von Argumenten entgegen, ähnlich wie die C-Funktion printf().

Beispiel:

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

Um die Ausgabe zur Laufzeit zu unterdrücken, installieren Sie Ihren eigenen Message-Handler mit qInstallMessageHandler().

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

qInfo(const char *message, ...)

Ruft den Message-Handler mit der informativen Nachricht message auf. Wenn kein Message-Handler installiert wurde, wird die Nachricht in stderr ausgegeben. Unter Windows wird die Nachricht an die Konsole gesendet, wenn es sich um eine Konsolenanwendung handelt; andernfalls wird sie an den Debugger gesendet. Unter QNX wird die Nachricht an slogger2 gesendet. Diese Funktion tut nichts, wenn QT_NO_INFO_OUTPUT während der Kompilierung definiert wurde.

Wenn Sie der Funktion einen Format-String und eine Liste von Argumenten übergeben, arbeitet sie ähnlich wie die C-Funktion printf(). Das Format sollte eine Latin-1 Zeichenkette sein.

Beispiel:

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

Wenn Sie <QtDebug> einbinden, ist auch eine bequemere Syntax verfügbar:

qInfo() << "Brush:" << myQBrush << "Other value:" << i;

Mit dieser Syntax gibt die Funktion ein QDebug Objekt zurück, das für die Verwendung des QtInfoMsg Nachrichtentyps konfiguriert ist. Sie setzt automatisch ein einzelnes Leerzeichen zwischen die einzelnen Elemente und gibt am Ende einen Zeilenumbruch aus. Sie unterstützt viele C++- und Qt-Typen.

Um die Ausgabe zur Laufzeit zu unterdrücken, installieren Sie Ihren eigenen Message-Handler mit qInstallMessageHandler().

Hinweis: Dieses Makro ist thread-sicher.

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

qWarning(const char *message, ...)

Ruft den Message-Handler mit der Warnmeldung message auf. Wenn kein Message-Handler installiert ist, wird die Meldung in stderr ausgegeben. Unter Windows wird die Nachricht an den Debugger gesendet. Unter QNX wird die Nachricht an slogger2 gesendet.

Diese Funktion nimmt eine Formatzeichenkette und eine Liste von Argumenten entgegen, ähnlich wie die C-Funktion printf(). Das Format sollte eine Latin-1 Zeichenkette sein.

Beispiel:

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

Wenn Sie <QtDebug> einbinden, ist auch eine bequemere Syntax verfügbar:

qWarning() << "Brush:" << myQBrush << "Other value:" << i;

Diese Syntax fügt ein Leerzeichen zwischen den einzelnen Elementen ein und hängt am Ende einen Zeilenumbruch an.

Diese Funktion bewirkt nichts, wenn QT_NO_WARNING_OUTPUT während der Kompilierung definiert wurde. Um die Ausgabe zur Laufzeit zu unterdrücken, können Sie logging rules setzen oder eine eigene filter registrieren.

Zu Debugging-Zwecken ist es manchmal praktisch, das Programm bei Warnmeldungen abbrechen zu lassen. Dadurch können Sie den Kernspeicherauszug untersuchen oder einen Debugger anschließen - siehe auch qFatal(). Um dies zu ermöglichen, setzen Sie die Umgebungsvariable QT_FATAL_WARNINGS auf eine Zahl n. Das Programm bricht dann bei der n-ten Warnung ab. Das heißt, wenn die Umgebungsvariable auf 1 gesetzt ist, wird es beim ersten Aufruf beendet; wenn sie den Wert 10 enthält, wird es beim zehnten Aufruf beendet. Jeder nicht-numerische Wert in der Umgebungsvariablen ist gleichbedeutend mit 1.

Hinweis: Dieses Makro ist thread-sicher.

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

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