QLoggingCategory Class

Die Klasse QLoggingCategory repräsentiert eine Kategorie oder einen "Bereich" in der Logging-Infrastruktur. Mehr...

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

Hinweis: Alle Funktionen in dieser Klasse sind thread-sicher.

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

Detaillierte Beschreibung

QLoggingCategory repräsentiert eine bestimmte Protokollierungskategorie - identifiziert durch einen String - zur Laufzeit. Eine Kategorie kann so konfiguriert werden, dass die Protokollierung von Meldungen pro Meldungstyp aktiviert oder deaktiviert wird. Eine Ausnahme sind fatale Meldungen, die immer aktiviert sind.

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

Alle Objekte sollen über eine gemeinsame Registrierung konfiguriert werden, wie in Configuring Categories beschrieben. Verschiedene Objekte können auch dieselbe Kategorie repräsentieren. Daher ist es nicht empfehlenswert, Objekte über Modulgrenzen hinweg zu exportieren, die Objekte direkt zu manipulieren oder von QLoggingCategory zu erben.

Erstellen von Kategorie-Objekten

Die Makros Q_DECLARE_LOGGING_CATEGORY() und Q_LOGGING_CATEGORY() deklarieren und erstellen bequem QLoggingCategory-Objekte:

// in a header
Q_DECLARE_LOGGING_CATEGORY(driverUsb)

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

Es gibt auch das Q_DECLARE_EXPORTED_LOGGING_CATEGORY() Makro, um eine Logging-Kategorie über Bibliotheksgrenzen hinweg zu verwenden.

Kategorienamen sind freier Text; um Kategorien mit Logging Rules zu konfigurieren, sollten ihre Namen dieser Konvention folgen:

  • Verwenden Sie nur Buchstaben und Zahlen.
  • Verwenden Sie Punkte, um die Kategorien weiter in gemeinsame Bereiche zu strukturieren.
  • Vermeiden Sie die 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 sind, werden bei der ersten Verwendung auf eine thread-sichere Weise erstellt.

Überprüfen der Kategoriekonfiguration

QLoggingCategory stellt isDebugEnabled(), isInfoEnabled(), isWarningEnabled(), isCriticalEnabled(), sowie isEnabled() zur Verfügung, um zu prüfen, ob Meldungen für den angegebenen Meldungstyp protokolliert werden sollen.

Die Makros qCDebug(), qCWarning() und qCCritical() verhindern, dass Argumente ausgewertet werden, wenn die entsprechenden Meldungstypen für die Kategorie nicht aktiviert sind, so dass eine explizite Prüfung nicht erforderlich ist:

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

Standard-Kategorie-Konfiguration

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

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

deklarierte Kategorie protokolliert Meldungen des Typs QtWarningMsg, QtCriticalMsg, QtFatalMsg, ignoriert aber Meldungen des Typs QtDebugMsg und QtInfoMsg.

Wenn kein Argument übergeben wird, werden alle Meldungen protokolliert. Nur Qt-interne Kategorien, die mit qt beginnen, werden anders behandelt: Für diese werden standardmäßig nur Meldungen des Typs QtInfoMsg, QtWarningMsg, QtCriticalMsg und QFatalMsg protokolliert.

Hinweis: Die Protokollierungskategorien werden nicht von Ihrer C++-Build-Konfiguration beeinflusst. Das heißt, ob Meldungen gedruckt werden, hängt nicht davon ab, ob der Code mit Debugsymbolen ("Debug Build"), Optimierungen ("Release Build") oder einer anderen Kombination kompiliert wurde.

Konfigurieren von Kategorien

Sie können die Standardkonfiguration für Kategorien außer Kraft setzen, indem Sie entweder Protokollierungsregeln festlegen oder einen benutzerdefinierten Filter installieren.

Protokollierungsregeln

Mit den Protokollierungsregeln können Sie die Protokollierung für Kategorien auf flexible Weise aktivieren oder deaktivieren. Die Regeln werden in Textform angegeben, wobei jede Zeile das 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 Stellen. Das optionale <type> muss debug, info, warning, oder critical sein. Zeilen, die nicht in dieses Schema passen, werden ignoriert.

Die Regeln werden in der Reihenfolge des Textes ausgewertet, vom ersten bis zum letzten Zeichen. Das heißt, wenn zwei Regeln auf eine Kategorie/einen Typ zutreffen, wird die spätere Regel angewendet.

Regeln können über setFilterRules() gesetzt werden:

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

Die Protokollierungsregeln werden automatisch aus dem Abschnitt [Rules] in einer Protokollierungskonfigurationsdatei geladen. Diese Konfigurationsdateien werden im QtProject-Konfigurationsverzeichnis nachgeschlagen oder explizit in einer QT_LOGGING_CONF Umgebungsvariablen gesetzt:

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

Logging-Regeln können auch in einer QT_LOGGING_RULES Umgebungsvariablen angegeben werden; mehrere Regeln können auch durch Semikolon getrennt werden:

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

Regeln, die durch setFilterRules() gesetzt werden, haben Vorrang vor Regeln, die im QtProject-Konfigurationsverzeichnis angegeben sind. Diese Regeln können wiederum von denen aus der Konfigurationsdatei überschrieben werden, die durch QT_LOGGING_CONF angegeben werden, und von denen, die durch QT_LOGGING_RULES gesetzt werden.

Die Reihenfolge der Auswertung ist wie folgt:

  1. [QLibraryInfo::DataPath]/qtlogging.ini
  2. QtProjekt/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.

Setzen Sie die Umgebungsvariable QT_LOGGING_DEBUG, um herauszufinden, woher Ihre Protokollierungsregeln geladen werden.

Installieren eines benutzerdefinierten Filters

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

Drucken der Kategorie

Verwenden Sie den Platzhalter %{category}, um die Kategorie im Standard Message Handler zu drucken:

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

Mitgliedstyp Dokumentation

QLoggingCategory::CategoryFilter

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

void myCategoryFilter(QLoggingCategory *);

Eine Funktion mit dieser Signatur kann mit installFilter() installiert werden.

Dokumentation der Mitgliedsfunktionen

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

Konstruiert ein QLoggingCategory-Objekt mit dem angegebenen Namen category und aktiviert alle Meldungen, deren Typ mindestens so ausführlich ist wie enableForLevel, dessen Standardwert QtDebugMsg ist (was alle Kategorien aktiviert).

Wenn category nullptr ist, wird der Kategoriename "default" verwendet.

Hinweis: category muss während der Lebensdauer dieses Objekts gültig bleiben. Der übliche Weg, dies zu erreichen, ist die Verwendung eines String-Literales für dieses Objekt.

[noexcept] QLoggingCategory::~QLoggingCategory()

Zerstört 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 z.B. von qDebug(), qInfo(), qWarning(), qCritical() oder qFatal() verwendet wird.

Hinweis: Der zurückgegebene Zeiger kann bei der Zerstörung von statischen Objekten null sein. Außerdem sollte dieser Zeiger nicht delete werden, da das Eigentum an der Kategorie nicht übertragen wird.

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

Übernehmen Sie die Kontrolle darüber, wie die Protokollierungskategorien konfiguriert werden.

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

Jedes QLoggingCategory Objekt, das bereits existiert, wird an den Filter übergeben, bevor installFilter() zurückkehrt, und es steht dem Filter frei, die Konfiguration jeder Kategorie mit setEnabled() zu ändern. Jede Kategorie, die er nicht ändert, behält die Konfiguration, die ihr vom vorherigen Filter gegeben wurde, so dass der neue Filter während dieses anfänglichen Durchlaufs über bestehende Kategorien nicht an den vorherigen Filter delegieren muss.

Alle später hinzugefügten Kategorien werden an den neuen Filter weitergegeben; ein Filter, der nur die Konfiguration einiger ausgewählter Kategorien ändern will, anstatt die Protokollierungsrichtlinie komplett außer Kraft zu setzen, kann die neue Kategorie zunächst an den vorherigen Filter weitergeben, um ihr die Standardkonfiguration zu geben, und diese dann wie gewünscht ändern, wenn sie eine der Kategorien ist, die für den Filter von besonderem Interesse sind. Der Code, der den neuen Filter installiert, kann die Rückgabe von installFilter() aufzeichnen, damit der Filter sie bei späteren Aufrufen verwenden kann.

Beachten Sie bei der Definition Ihres Filters, dass er von verschiedenen Threads aus aufgerufen werden kann, aber niemals gleichzeitig. Dieser Filter kann keine statischen Funktionen von 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()) von

oldCategoryFilter = QLoggingCategory::installFilter(myCategoryFilter);

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

bool QLoggingCategory::isCriticalEnabled() const

Gibt true zurück, wenn für diese Kategorie kritische Meldungen 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 nützlich sein, um die teure Erzeugung von Daten nur für die Debug-Ausgabe zu vermeiden.

bool QLoggingCategory::isDebugEnabled() const

Gibt true zurück, wenn Debug-Meldungen für diese Kategorie 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 nützlich sein, um die teure Erzeugung von Daten nur für Debug-Ausgaben zu vermeiden.

bool QLoggingCategory::isEnabled(QtMsgType msgtype) const

Gibt true zurück, wenn eine Meldung des Typs msgtype für die Kategorie angezeigt werden soll; andernfalls false.

bool QLoggingCategory::isInfoEnabled() const

Gibt true zurück, wenn Informationsmeldungen für diese Kategorie 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 nützlich sein, um die teure Erzeugung von Daten nur für die Debug-Ausgabe zu vermeiden.

bool QLoggingCategory::isWarningEnabled() const

Gibt true zurück, wenn Warnmeldungen für diese Kategorie 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 nützlich sein, um die teure Erzeugung von Daten nur für die Debug-Ausgabe zu vermeiden.

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

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

Diese Methode ist nur für die Verwendung innerhalb eines mit installFilter() installierten Filters gedacht. Einen Überblick ü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 fest, welche Kategorien und Nachrichtentypen durch einen Satz von rules 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. Dies ermöglicht sowohl eine QLoggingCategory -Variable als auch eine Factory-Methode, die ein QLoggingCategory zurückgibt, um in den Makros qCDebug(), qCWarning(), qCCritical() oder qCFatal() verwendet zu werden.

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

Gibt das Objekt selbst zurück. Dies ermöglicht sowohl eine QLoggingCategory -Variable als auch eine Factory-Methode, die ein QLoggingCategory zurückgibt, in den Makros qCDebug(), qCWarning(), qCCritical() oder qCFatal() zu verwenden.

Makro-Dokumentation

[since 6.5] Q_DECLARE_EXPORTED_LOGGING_CATEGORY(name, EXPORT_MACRO)

Deklariert eine Protokollierungskategorie name. Das Makro kann verwendet werden, um eine gemeinsame Protokollierungskategorie zu deklarieren, die in verschiedenen Teilen des Programms verwendet wird.

Dies funktioniert genauso wie Q_DECLARE_LOGGING_CATEGORY(). Allerdings wird die mit diesem Makro deklarierte Protokollierungskategorie zusätzlich mit EXPORT_MACRO qualifiziert. Dies ist nützlich, wenn die Protokollierungskategorie aus einer dynamischen Bibliothek exportiert werden muss.

Ein 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 gemeinsame Protokollierungskategorie zu deklarieren, die in verschiedenen Teilen des Programms verwendet 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)

Legt eine Protokollierungskategorie name fest und macht sie unter dem Bezeichner string konfigurierbar. Standardmäßig sind alle Nachrichtentypen aktiviert.

Nur eine Übersetzungseinheit in einer Bibliothek oder ausführbaren Datei kann eine Kategorie mit einem bestimmten Namen definieren. Das implizit definierte Objekt QLoggingCategory wird bei der ersten Verwendung auf eine thread-sichere 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)

Legt eine Protokollierungskategorie name fest und macht sie unter dem Bezeichner string konfigurierbar. Standardmäßig sind Meldungen von QtMsgType msgType und schwerwiegenderen Typen aktiviert, Typen mit einem geringeren Schweregrad sind deaktiviert.

Nur eine Übersetzungseinheit in einer Bibliothek oder ausführbaren Datei kann eine Kategorie mit einem bestimmten Namen definieren. Das implizit definierte Objekt QLoggingCategory wird bei der ersten Verwendung auf eine thread-sichere Weise erstellt.

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

Siehe auch Q_DECLARE_LOGGING_CATEGORY().

qCCritical(category)

Gibt einen Ausgabestrom für kritische Nachrichten in der Protokollierungskategorie category zurück.

Das Makro erweitert sich zu einem Code, der prüft, ob QLoggingCategory::isCriticalEnabled() den Wert true ergibt. Wenn ja, werden die Stream-Argumente verarbeitet und an den Message-Handler 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 also nicht auf irgendwelche Nebeneffekte.

Siehe auch 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 die Argumente nicht verarbeitet, verlassen Sie sich also nicht auf irgendwelche Nebeneffekte.

Siehe auch qCritical().

qCDebug(category)

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

Das Makro erweitert sich zu einem Code, der prüft, ob QLoggingCategory::isDebugEnabled() den Wert true ergibt. Wenn ja, werden die Stream-Argumente verarbeitet und an den Message-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 also nicht auf irgendwelche Nebeneffekte.

Siehe auch 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 die 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 diese category nicht aktiviert ist, verlassen Sie sich also nicht auf irgendwelche Nebeneffekte.

Siehe auch qDebug().

[since 6.5] qCFatal(category)

Gibt einen Ausgabestrom für fatale Meldungen in der Kategorie Protokollierung zurück, category.

Wenn Sie den Standard-Meldungs-Handler verwenden, bricht der zurückgegebene Stream ab, um einen Core-Dump zu erstellen. Unter Windows meldet diese Funktion bei Debug-Builds eine _CRT_ERROR, die es Ihnen ermöglicht, einen Debugger mit der Anwendung zu verbinden.

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

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

Protokolliert eine fatale Meldung, message, in der Protokollierungskategorie, category. message kann Platzhalter enthalten, die durch zusätzliche Argumente ersetzt werden, ähnlich wie die 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, die es Ihnen ermöglicht, einen Debugger mit der Anwendung zu verbinden.

Dieses Makro wurde in Qt 6.5 eingeführt.

Siehe auch qFatal().

qCInfo(category)

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

Das Makro erweitert sich zu einem Code, der prüft, ob QLoggingCategory::isInfoEnabled() den Wert true ergibt. Wenn ja, werden die Stream-Argumente verarbeitet und an den Message-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 also nicht auf irgendwelche Nebeneffekte.

Siehe auch 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 die Argumente nicht verarbeitet, verlassen Sie sich also nicht auf irgendwelche Nebeneffekte.

Siehe auch qInfo().

qCWarning(category)

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

Das Makro erweitert sich zu einem Code, der prüft, ob QLoggingCategory::isWarningEnabled() den Wert true ergibt. Wenn ja, werden die Stream-Argumente verarbeitet und an den Message-Handler 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 also nicht auf irgendwelche Nebeneffekte.

Siehe auch 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 die C-Funktion printf().

Beispiel:

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

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

Siehe auch qWarning().

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