Auf dieser Seite

QLoggingCategory Class

Die Klasse „QLoggingCategory“ repräsentiert eine Kategorie oder einen „Bereich“ in der Protokollierungsinfrastruktur. Mehr...

Kopfzeile: #include <QLoggingCategory>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core

Hinweis: Alle Funktionen dieser Klasse sind threadsicher.

Öffentliche Typen

Öffentliche Funktionen

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

Statische öffentliche Mitglieder

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

Makros

(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, ...)

Ausführliche Beschreibung

QLoggingCategory repräsentiert zur Laufzeit eine bestimmte Protokollierungskategorie, die durch eine Zeichenkette identifiziert wird. Eine Kategorie kann so konfiguriert werden, dass die Protokollierung von Meldungen je nach Meldungstyp aktiviert oder deaktiviert wird. Eine Ausnahme bilden schwerwiegende Meldungen, die immer aktiviert sind.

Um zu prüfen, ob ein Meldungstyp aktiviert ist oder nicht, verwenden Sie eine der folgenden Methoden: ` isDebugEnabled()`, ` isInfoEnabled()`, ` isWarningEnabled()` und ` isCriticalEnabled()`.

Alle Objekte sind dafür vorgesehen, über eine gemeinsame Registrierung konfiguriert zu werden, wie unter Configuring Categories beschrieben. Verschiedene Objekte können auch dieselbe Kategorie repräsentieren. Daher wird davon abgeraten, Objekte über Modulgrenzen hinweg zu exportieren, die Objekte direkt zu manipulieren oder von `QLoggingCategory` zu erben.

Erstellen von Kategorieobjekten

Die Makros „ Q_DECLARE_LOGGING_CATEGORY()“ und „ Q_LOGGING_CATEGORY()“ dienen dazu, QLoggingCategory-Objekte bequem zu deklarieren und zu erstellen:

// in a header
Q_DECLARE_LOGGING_CATEGORY(driverUsb)

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

Außerdem gibt es das Makro ` Q_DECLARE_EXPORTED_LOGGING_CATEGORY()`, um eine Protokollierungskategorie bibliotheksübergreifend zu verwenden.

Kategorienamen sind frei wählbar; um Kategorien mit ` Logging Rules` zu konfigurieren, sollten ihre Namen dieser Konvention folgen:

  • Verwenden Sie ausschließlich Buchstaben und Zahlen.
  • Verwenden Sie Punkte, um Kategorien weiter in gemeinsame Bereiche zu gliedern.
  • Vermeiden Sie die folgenden Kategorienamen: „ debug “, „ info “, „ warning “ und „ critical “.
  • Kategorienamen mit dem Präfix „ qt “ sind ausschließlich für Qt-Module reserviert.

QLoggingCategory-Objekte, die implizit durch Q_LOGGING_CATEGORY() definiert werden, werden bei der ersten Verwendung threadsicher erstellt.

Überprüfung der Kategoriekonfiguration

QLoggingCategory stellt die Methoden isDebugEnabled(), isInfoEnabled(), isWarningEnabled(), isCriticalEnabled() sowie isEnabled() bereit, um zu prüfen, ob Meldungen des angegebenen Meldungstyps protokolliert werden sollen.

Die Makros „ qCDebug “ (), „ qCWarning “ () und „ qCCritical “ () verhindern die Auswertung von Argumenten, wenn die jeweiligen Meldungstypen für die Kategorie nicht aktiviert sind, sodass keine explizite Überprüfung erforderlich ist:

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

Standardkonfiguration der Kategorie

Sowohl der Konstruktor von `QLoggingCategory` als auch das Makro ` Q_LOGGING_CATEGORY()` akzeptieren ein optionales Argument ` QtMsgType `, das alle Meldungstypen mit niedrigerem Schweregrad deaktiviert. Das heißt, eine Kategorie, die mit

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

protokolliert Meldungen vom Typ „ QtWarningMsg “, „ QtCriticalMsg “ und „ QtFatalMsg “, ignoriert jedoch Meldungen vom Typ „ QtDebugMsg “ und „ QtInfoMsg “.

qt QtInfoMsg QtWarningMsg QtCriticalMsg QFatalMsg XML-Ph-0000@deepl.internal

Hinweis: DieProtokollierungskategorien werden von Ihrer C++-Build-Konfiguration nicht beeinflusst. Das heißt, ob Meldungen ausgegeben werden, hängt nicht davon ab, ob der Code mit Debug-Symbolen („Debug-Build“), Optimierungen („Release-Build“) oder einer anderen Kombination kompiliert wird.

Konfigurieren von Kategorien

Sie können die Standardkonfiguration für Kategorien entweder durch Festlegen von Protokollierungsregeln oder durch Installieren eines benutzerdefinierten Filters überschreiben.

Protokollierungsregeln

Mit Protokollierungsregeln können Sie die Protokollierung für Kategorien flexibel aktivieren oder deaktivieren. Regeln werden in Textform angegeben, wobei jede Zeile folgendes Format haben muss:

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

<category> ist der Name der Kategorie, möglicherweise mit „ * “ als Platzhalter für das erste oder letzte Zeichen – oder an beiden Positionen. Der optionale „ <type> “ muss „ debug “, „ info “, „ warning “ oder „ critical “ lauten. Zeilen, die diesem Schema nicht entsprechen, werden ignoriert.

Regeln werden in der Reihenfolge ihres Auftretens im Text ausgewertet, von der ersten bis zur letzten. Das heißt, wenn zwei Regeln auf eine Kategorie/einen Typ zutreffen, wird die später auftretende Regel angewendet.

Regeln können über ` setFilterRules()` festgelegt werden:

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

Protokollierungsregeln werden automatisch aus dem Abschnitt „ [Rules] “ in einer Protokollierungskonfigurationsdatei geladen. Diese Konfigurationsdateien werden im QtProject-Konfigurationsverzeichnis gesucht oder explizit in der Umgebungsvariablen „ QT_LOGGING_CONF “ festgelegt:

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

Protokollierungsregeln können auch in der Umgebungsvariablen ` QT_LOGGING_RULES ` angegeben werden; mehrere Regeln können dabei durch Semikolons getrennt werden:

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

Regeln, die über ` setFilterRules()` festgelegt werden, haben Vorrang vor Regeln, die im QtProject-Konfigurationsverzeichnis angegeben sind. Diese Regeln können wiederum durch diejenigen aus der über ` QT_LOGGING_CONF` angegebenen Konfigurationsdatei sowie durch die über ` QT_LOGGING_RULES` festgelegten Regeln überschrieben werden.

Die Reihenfolge der Auswertung ist wie folgt:

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

Die Datei „ QtProject/qtlogging.ini “ wird in allen Verzeichnissen gesucht, die von „ QStandardPaths::GenericConfigLocation “ zurückgegeben werden.

Legen Sie die Umgebungsvariable ` QT_LOGGING_DEBUG ` fest, um herauszufinden, von wo Ihre Protokollierungsregeln geladen werden.

Installieren eines benutzerdefinierten Filters

Als Alternative auf niedrigerer Ebene zu den Textregeln können Sie auch einen benutzerdefinierten Filter über ` installFilter()` implementieren. In diesem Fall werden alle Filterregeln ignoriert.

Ausgeben der Kategorie

Verwenden Sie den Platzhalter „ %{category} “, um die Kategorie im Standard-Meldungshandler auszugeben:

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

Dokumentation zum Mitgliedstyp

QLoggingCategory::CategoryFilter

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

void myCategoryFilter(QLoggingCategory *);

Eine Funktion mit dieser Signatur kann mit ` installFilter()` aufgerufen werden.

Dokumentation zu den Member-Funktionen

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

Erstellt ein QLoggingCategory-Objekt mit dem angegebenen Namen „ category “ und aktiviert alle Meldungen, deren Typ mindestens so ausführlich ist wie „ enableForLevel “; der Standardwert ist „ QtDebugMsg “ (wodurch alle Kategorien aktiviert werden).

Wenn „ category “ den Wert „ nullptr “ hat, wird der Kategoriename „ "default" “ verwendet.

Hinweis: category muss während der gesamten Lebensdauer dieses Objekts gültig bleiben. Dies wird üblicherweise durch die Verwendung eines String-Literals erreicht.

[noexcept] QLoggingCategory::~QLoggingCategory()

Löscht ein „ QLoggingCategory “-Objekt.

const char *QLoggingCategory::categoryName() const

Gibt den Namen der Kategorie zurück.

[static] QLoggingCategory *QLoggingCategory::defaultCategory()

Gibt einen Zeiger auf die globale Kategorie „ "default" “ zurück, die beispielsweise von den Funktionen „ qDebug()“, „ qInfo()“, „ qWarning()“, „ qCritical()“ oder „ qFatal()“ verwendet wird.

Hinweis: Der zurückgegebene Zeiger kann während der Zerstörung statischer Objekte den Wert null annehmen. Verwenden Sie diesen Zeiger außerdem nicht für ` delete `, da die Eigentumsrechte an der Kategorie nicht übertragen werden.

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

Legen Sie fest, wie die Protokollierungskategorien konfiguriert werden.

Installiert eine Funktion „ filter “, mit der festgelegt wird, welche Kategorien und Meldungstypen aktiviert werden sollen. Wenn „ filter “ auf „ nullptr “ gesetzt ist, wird der Standard-Meldungsfilter wiederhergestellt. Gibt einen Zeiger auf den zuvor installierten Filter zurück.

Jedes bereits vorhandene ` QLoggingCategory `-Objekt wird an den Filter übergeben, bevor ` installFilter() ` zurückkehrt, und der Filter kann die Konfiguration jeder Kategorie mit ` setEnabled()` beliebig ändern. Jede Kategorie, die nicht geändert wird, behält die vom vorherigen Filter übergebene Konfiguration bei, sodass der neue Filter während dieses ersten Durchlaufs durch die vorhandenen Kategorien nicht auf den vorherigen Filter zurückgreifen muss.

Alle später hinzugefügten neuen Kategorien werden an den neuen Filter übergeben; ein Filter, der lediglich die Konfiguration einiger ausgewählter Kategorien anpassen möchte, anstatt die Protokollierungsrichtlinie vollständig zu überschreiben, kann die neue Kategorie zunächst an den vorherigen Filter übergeben, um ihr die Standardkonfiguration zuzuweisen, und diese dann nach Belieben anpassen, sofern es sich um eine Kategorie handelt, die für den Filter von besonderem Interesse ist. Der Code, der den neuen Filter installiert, kann den Rückgabewert von ` installFilter() ` für den Filter aufzeichnen, damit dieser ihn bei späteren Aufrufen verwenden kann.

Beachten Sie bei der Definition Ihres Filters, dass dieser aus verschiedenen Threads aufgerufen werden kann, jedoch niemals gleichzeitig. Dieser Filter darf keine statischen Funktionen aus ` QLoggingCategory` aufrufen.

Beispiel:

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

installiert (z. B. in ` main()`) durch

oldCategoryFilter = QLoggingCategory::installFilter(myCategoryFilter);

Alternativ können Sie den Standardfilter über ` setFilterRules()` konfigurieren.

bool QLoggingCategory::isCriticalEnabled() const

Gibt „ true “ zurück, wenn kritische Meldungen für diese Kategorie angezeigt werden sollen; andernfalls „ false “.

Hinweis: Das Makro „ qCCritical()“ führt diese Prüfung bereits vor der Ausführung von Code durch. Der Aufruf dieser Methode kann jedoch sinnvoll sein, um die rechenintensive Generierung von Daten zu vermeiden, die ausschließlich für die Debug-Ausgabe bestimmt sind.

bool QLoggingCategory::isDebugEnabled() const

Gibt „ true “ zurück, wenn für diese Kategorie Debug-Meldungen angezeigt werden sollen; andernfalls „ false “.

Hinweis: Das Makro „ qCDebug()“ führt diese Prüfung bereits vor der Ausführung von Code durch. Der Aufruf dieser Methode kann jedoch sinnvoll sein, um die rechenintensive Generierung von Daten zu vermeiden, die ausschließlich für die Debug-Ausgabe bestimmt sind.

bool QLoggingCategory::isEnabled(QtMsgType msgtype) const

Gibt „ true “ zurück, wenn eine Nachricht vom Typ „ msgtype “ für die Kategorie angezeigt werden soll; andernfalls „ false “.

bool QLoggingCategory::isInfoEnabled() const

Gibt „ true “ zurück, wenn für diese Kategorie Informationsmeldungen angezeigt werden sollen; andernfalls „ false “.

Hinweis: Das Makro „ qCInfo()“ führt diese Prüfung bereits vor der Ausführung von Code durch. Der Aufruf dieser Methode kann jedoch sinnvoll sein, um die aufwendige Generierung von Daten zu vermeiden, die ausschließlich für die Debug-Ausgabe bestimmt sind.

bool QLoggingCategory::isWarningEnabled() const

Gibt „ true “ zurück, wenn für diese Kategorie Warnmeldungen angezeigt werden sollen; andernfalls „ false “.

Hinweis: Das Makro „ qCWarning()“ führt diese Prüfung bereits vor der Ausführung von Code durch. Der Aufruf dieser Methode kann jedoch sinnvoll sein, um die rechenintensive Generierung von Daten zu vermeiden, die ausschließlich für die Debug-Ausgabe bestimmt sind.

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

Ändert den Nachrichtentyp „ type “ für die Kategorie in „ enable “.

Diese Methode ist ausschließlich für die Verwendung innerhalb eines mit ` installFilter()` installierten Filters vorgesehen. Eine Übersicht über die globale Konfiguration von Kategorien finden Sie unter ` Configuring Categories`.

Hinweis: „ QtFatalMsg “ kann nicht geändert werden; es bleibt immer „ true “.

Siehe auch isEnabled().

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

Legt über eine Reihe von „ rules “ fest, welche Kategorien und Nachrichtentypen aktiviert werden sollen.

Beispiel:

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

Hinweis: Die Regeln werden möglicherweise ignoriert, wenn ein benutzerdefinierter Kategoriefilter mit ` installFilter()` installiert wurde oder wenn der Benutzer die Umgebungsvariable ` QT_LOGGING_CONF ` oder ` QT_LOGGING_RULES ` definiert hat.

QLoggingCategory &QLoggingCategory::operator()()

Gibt das Objekt selbst zurück. Dadurch können sowohl eine Variable vom Typ „ QLoggingCategory “ als auch eine Factory-Methode, die ein „ QLoggingCategory “ zurückgibt, in den Makros „ qCDebug()“, „ qCWarning()“, „ qCCritical()“ oder „ qCFatal()“ verwendet werden.

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

Gibt das Objekt selbst zurück. Dies ermöglicht sowohl die Verwendung einer Variablen vom Typ „ QLoggingCategory “ als auch einer Factory-Methode, die einen „ QLoggingCategory “ zurückgibt, in den Makros „ qCDebug()“, „ qCWarning()“, „ qCCritical()“ oder „ qCFatal()“.

Makro-Dokumentation

[since 6.5] Q_DECLARE_EXPORTED_LOGGING_CATEGORY(name, EXPORT_MACRO)

Deklariert eine Protokollierungskategorie „ name “. Das Makro kann verwendet werden, um eine allgemeine Protokollierungskategorie zu deklarieren, die in verschiedenen Teilen des Programms gemeinsam genutzt wird.

Dies funktioniert genau wie ` Q_DECLARE_LOGGING_CATEGORY()`. Die durch dieses Makro deklarierte Protokollierungskategorie wird jedoch zusätzlich mit ` EXPORT_MACRO` qualifiziert. Dies ist nützlich, wenn die Protokollierungskategorie aus einer dynamischen Bibliothek exportiert werden soll.

Beispiel:

Q_DECLARE_EXPORTED_LOGGING_CATEGORY(lcCore, LIB_EXPORT_MACRO)

Dieses Makro muss außerhalb einer Klasse oder Funktion verwendet werden.

Dieses Makro wurde in Qt 6.5 eingeführt.

Siehe auch Q_LOGGING_CATEGORY() und Q_DECLARE_LOGGING_CATEGORY().

Q_DECLARE_LOGGING_CATEGORY(name)

Deklariert eine Protokollierungskategorie „ name “. Das Makro kann verwendet werden, um eine allgemeine Protokollierungskategorie zu deklarieren, die in verschiedenen Teilen des Programms gemeinsam genutzt wird.

Dieses Makro muss außerhalb einer Klasse oder Methode verwendet werden.

Siehe auch „ Q_LOGGING_CATEGORY()“ und „ Q_DECLARE_EXPORTED_LOGGING_CATEGORY()“.

Q_LOGGING_CATEGORY(name, string)

Definiert eine Protokollierungskategorie „ name “ und macht diese unter dem Bezeichner „ string “ konfigurierbar. Standardmäßig sind alle Meldungstypen aktiviert.

In einer Bibliothek oder einer ausführbaren Datei darf nur eine Übersetzungseinheit eine Kategorie mit einem bestimmten Namen definieren. Das implizit definierte Objekt „ QLoggingCategory “ wird bei der ersten Verwendung auf threadsichere Weise erstellt.

Dieses Makro muss außerhalb einer Klasse oder Methode verwendet werden.

Siehe auch ` Q_DECLARE_LOGGING_CATEGORY()` und ` Q_DECLARE_EXPORTED_LOGGING_CATEGORY()`.

Q_LOGGING_CATEGORY(name, string, msgType)

Definiert eine Protokollierungskategorie „ name “ und macht sie unter dem Bezeichner „ string “ konfigurierbar. Standardmäßig sind Meldungen der Schweregrade „ QtMsgType “, „ msgType “ und höher aktiviert; Meldungen mit niedrigerem Schweregrad sind deaktiviert.

In einer Bibliothek oder einer ausführbaren Datei darf nur eine Übersetzungseinheit eine Kategorie mit einem bestimmten Namen definieren. Das implizit definierte Objekt „ QLoggingCategory “ wird bei der ersten Verwendung auf threadsichere Weise erstellt.

Dieses Makro muss außerhalb einer Klasse oder Methode verwendet werden.

Siehe auch ` Q_DECLARE_LOGGING_CATEGORY()`.

[since 6.9] Q_STATIC_LOGGING_CATEGORY(name, string)

Definiert eine statische Protokollierungskategorie „ name “ und macht sie unter dem Bezeichner „ string “ konfigurierbar. Standardmäßig sind alle Meldungstypen aktiviert.

Die Protokollierungskategorie wird mit dem Qualifizierer „ static “ erstellt, sodass Sie nur innerhalb derselben Übersetzungseinheit darauf zugreifen können. Dadurch werden versehentliche Symbolkonflikte vermieden.

Das implizit definierte Objekt ` QLoggingCategory ` wird bei der ersten Verwendung threadsicher angelegt.

Dieses Makro muss außerhalb einer Klasse oder Methode verwendet werden.

Dieses Makro wurde in Qt 6.9 eingeführt.

Siehe auch ` Q_LOGGING_CATEGORY()`.

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

Definiert eine statische Protokollierungskategorie „ name “ und macht sie unter dem Bezeichner „ string “ konfigurierbar. Standardmäßig sind Meldungen der Schweregrade „ QtMsgType “, „ msgType “ und höher aktiviert; Meldungen mit niedrigerem Schweregrad sind deaktiviert.

Die Protokollierungskategorie wird unter Verwendung des Qualifizierers „ static “ erstellt, sodass Sie nur innerhalb derselben Übersetzungseinheit darauf zugreifen können. Dadurch werden versehentliche Symbolkonflikte vermieden.

Das implizit definierte Objekt „ QLoggingCategory “ wird bei der ersten Verwendung threadsicher erstellt.

Dieses Makro muss außerhalb einer Klasse oder Methode verwendet werden.

Dieses Makro wurde in Qt 6.9 eingeführt.

Siehe auch ` Q_LOGGING_CATEGORY()`.

qCCritical(category)

Gibt einen Ausgabestrom für kritische Meldungen in der Protokollierungskategorie „ category “ zurück.

Das Makro wird zu Code erweitert, der prüft, ob „ QLoggingCategory::isCriticalEnabled()“ den Wert „ true “ ergibt. Ist dies der Fall, werden die Stream-Argumente verarbeitet und an den Nachrichtenhandler gesendet.

Beispiel:

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

Hinweis: Wenn die kritische Ausgabe für eine bestimmte Kategorie nicht aktiviert ist, werden die Argumente nicht verarbeitet; verlassen Sie sich daher nicht auf etwaige Nebeneffekte.

Siehe auch ` QDebug::qCritical()`.

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

Protokolliert eine kritische Meldung, „ message “, in der Protokollierungskategorie „ category “. „ message “ kann Platzhalter enthalten, die durch zusätzliche Argumente ersetzt werden, ähnlich wie bei der C-Funktion printf().

Beispiel:

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

Hinweis: Wenn die kritische Ausgabe für eine bestimmte Kategorie nicht aktiviert ist, werden Argumente nicht verarbeitet; verlassen Sie sich daher nicht auf etwaige Nebeneffekte.

Siehe auch qCritical(const char *, ...).

qCDebug(category)

Gibt einen Ausgabestrom für Debug-Meldungen in der Protokollierungskategorie „ category “ zurück.

Das Makro wird zu Code erweitert, der prüft, ob QLoggingCategory::isDebugEnabled() den Wert true ergibt. Ist dies der Fall, werden die Stream-Argumente verarbeitet und an den Nachrichten-Handler gesendet.

Beispiel:

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

Hinweis: Argumente werden nicht verarbeitet, wenn die Debug-Ausgabe für diese „ category “ nicht aktiviert ist; verlassen Sie sich daher nicht auf etwaige Nebeneffekte.

Siehe auch ` QDebug::qDebug()`.

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

Protokolliert eine Debug-Meldung, „ message “, in der Protokollierungskategorie „ category “. „ message “ kann Platzhalter enthalten, die durch zusätzliche Argumente ersetzt werden, ähnlich wie bei der C-Funktion printf().

Beispiel:

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

Hinweis: Argumente werden nicht verarbeitet, wenn die Debug-Ausgabe für diesen „ category “ nicht aktiviert ist. Verlassen Sie sich daher nicht auf Nebenwirkungen.

Siehe auch ` qDebug(const char *, ...)`.

[since 6.5] qCFatal(category)

Gibt einen Ausgabestrom für schwerwiegende Meldungen in der Protokollierungskategorie „ category “ zurück.

Wenn Sie den Standard-Meldungshandler verwenden, bricht der zurückgegebene Stream ab, um einen Core-Dump zu erstellen. Unter Windows meldet diese Funktion bei Debug-Builds ein „ _CRT_ERROR “, wodurch Sie einen Debugger an die Anwendung anschließen können.

Beispiel:

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

Dieses Makro wurde in Qt 6.5 eingeführt.

Siehe auch ` QDebug::qFatal()`.

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

Protokolliert eine schwerwiegende Meldung („ message “) in der Protokollierungskategorie „ category “. „ message “ kann Platzhalter enthalten, die durch zusätzliche Argumente ersetzt werden, ähnlich wie bei der C-Funktion printf().

Beispiel:

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

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

Dieses Makro wurde in Qt 6.5 eingeführt.

Siehe auch ` qFatal(const char *, ...)`.

qCInfo(category)

Gibt einen Ausgabestrom für Informationsmeldungen in der Protokollierungskategorie „ category “ zurück.

Das Makro wird zu Code erweitert, der prüft, ob „ QLoggingCategory::isInfoEnabled()“ den Wert „ true “ ergibt. Ist dies der Fall, werden die Stream-Argumente verarbeitet und an den Nachrichten-Handler gesendet.

Beispiel:

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

Hinweis: Wenn die Debug-Ausgabe für eine bestimmte Kategorie nicht aktiviert ist, werden die Argumente nicht verarbeitet; verlassen Sie sich daher nicht auf etwaige Nebeneffekte.

Siehe auch ` QDebug::qInfo()`.

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

Protokolliert eine Informationsmeldung, „ message “, in der Protokollierungskategorie „ category “. „ message “ kann Platzhalter enthalten, die durch zusätzliche Argumente ersetzt werden, ähnlich wie bei der C-Funktion printf().

Beispiel:

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

Hinweis: Wenn die Debug-Ausgabe für eine bestimmte Kategorie nicht aktiviert ist, werden Argumente nicht verarbeitet; verlassen Sie sich daher nicht auf etwaige Nebeneffekte.

Siehe auch „ qInfo“ (const char *, ...).

qCWarning(category)

Gibt einen Ausgabestrom für Warnmeldungen in der Protokollierungskategorie „ category “ zurück.

Das Makro wird zu Code erweitert, der prüft, ob „ QLoggingCategory::isWarningEnabled()“ den Wert „ true “ ergibt. Ist dies der Fall, werden die Stream-Argumente verarbeitet und an den Nachrichtenhandler gesendet.

Beispiel:

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

Hinweis: Wenn die Warnausgabe für eine bestimmte Kategorie nicht aktiviert ist, werden die Argumente nicht verarbeitet; verlassen Sie sich daher nicht auf etwaige Nebeneffekte.

Siehe auch ` QDebug::qWarning()`.

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

Protokolliert eine Warnmeldung, „ message “, in der Protokollierungskategorie „ category “. „ message “ kann Platzhalter enthalten, die durch zusätzliche Argumente ersetzt werden, ähnlich wie bei der C-Funktion printf().

Beispiel:

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

Hinweis: Wenn die Ausgabe von Warnungen für eine bestimmte Kategorie nicht aktiviert ist, werden die Argumente nicht verarbeitet; verlassen Sie sich daher nicht auf etwaige Nebeneffekte.

Siehe auch 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.