En esta página

QLoggingCategory Class

La clase QLoggingCategory representa una categoría, o 'área' en la infraestructura de registro. Más...

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

Nota: Todas las funciones de esta clase son thread-safe.

Tipos Públicos

Funciones Públicas

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

Miembros públicos estáticos

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

Macros

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

Descripción Detallada

QLoggingCategory representa una determinada categoría de registro - identificada por una cadena - en tiempo de ejecución. Una categoría puede ser configurada para habilitar o deshabilitar el registro de mensajes por tipo de mensaje. Una excepción son los mensajes fatales, que siempre están habilitados.

Para comprobar si un tipo de mensaje está habilitado o no, utilice uno de estos métodos: isDebugEnabled(), isInfoEnabled(), isWarningEnabled() y isCriticalEnabled().

Todos los objetos deben configurarse mediante un registro común, como se describe en Configuring Categories. Diferentes objetos también pueden representar la misma categoría. Por lo tanto, no se recomienda exportar objetos a través de los límites del módulo, manipular los objetos directamente, o heredar de QLoggingCategory.

Creación de objetos de categoría

Las macros Q_DECLARE_LOGGING_CATEGORY() y Q_LOGGING_CATEGORY() declaran y crean convenientemente objetos QLoggingCategory:

// in a header
Q_DECLARE_LOGGING_CATEGORY(driverUsb)

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

También existe la macro Q_DECLARE_EXPORTED_LOGGING_CATEGORY() para utilizar una categoría de registro a través de los límites de la biblioteca.

Los nombres de categoría son texto libre; para configurar categorías usando Logging Rules, sus nombres deben seguir esta convención:

  • Utilice sólo letras y números.
  • Utilice puntos para estructurar mejor las categorías en áreas comunes.
  • Evite los nombres de categoría debug, info, warning, y critical.
  • Los nombres de categoría con el prefijo qt están reservados únicamente para módulos Qt.

Los objetos QLoggingCategory definidos implícitamente por Q_LOGGING_CATEGORY() se crean en el primer uso, de forma segura para los hilos.

Comprobación de la configuración de la categoría

QLoggingCategory proporciona isDebugEnabled(), isInfoEnabled(), isWarningEnabled(), isCriticalEnabled(), así como isEnabled() para comprobar si los mensajes para el tipo de mensaje dado deben ser registrados.

Las macros qCDebug(), qCWarning(), y qCCritical() evitan que los argumentos sean evaluados si los respectivos tipos de mensaje no están habilitados para la categoría, por lo que no es necesaria una comprobación explícita:

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

Configuración por defecto de la categoría

Tanto el constructor QLoggingCategory como la macro Q_LOGGING_CATEGORY() aceptan un argumento opcional QtMsgType, que deshabilita todos los tipos de mensaje con una severidad menor. Es decir, una categoría declarada con

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

registra mensajes de tipo QtWarningMsg, QtCriticalMsg, QtFatalMsg, pero ignora los mensajes de tipo QtDebugMsg y QtInfoMsg.

Si no se pasa ningún argumento, se registran todos los mensajes. Sólo las categorías internas de Qt que empiezan por qt se tratan de forma diferente: Para éstas, sólo los mensajes de tipo QtInfoMsg, QtWarningMsg, QtCriticalMsg, y QFatalMsg se registran por defecto.

Nota: Las categorías de registro no se ven afectadas por la configuración de compilación de C++. Es decir, la impresión de mensajes no cambia dependiendo de si el código se compila con símbolos de depuración ('Debug Build'), optimizaciones ('Release Build'), o alguna otra combinación.

Configuración de categorías

Puede anular la configuración predeterminada de las categorías estableciendo reglas de registro o instalando un filtro personalizado.

Reglas de registro

Las reglas de registro le permiten activar o desactivar el registro de categorías de forma flexible. Las reglas se especifican en texto, donde cada línea debe tener el formato

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

<category> es el nombre de la categoría, potencialmente con * como símbolo comodín para el primer o último carácter; o en ambas posiciones. El <type> opcional debe ser debug, info, warning, o critical. Las líneas que no se ajustan a este esquema se ignoran.

Las reglas se evalúan en el orden del texto, de la primera a la última. Es decir, si dos reglas se aplican a una categoría/tipo, se aplica la regla que viene después.

Las reglas pueden establecerse mediante setFilterRules():

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

Las reglas de registro se cargan automáticamente desde la sección [Rules] de un archivo de configuración de registro. Estos archivos de configuración se buscan en el directorio de configuración de QtProject, o se establecen explícitamente en una variable de entorno QT_LOGGING_CONF:

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

Las reglas de registro también se pueden especificar en una variable de entorno QT_LOGGING_RULES; también se pueden separar varias reglas mediante punto y coma:

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

Las reglas establecidas por setFilterRules() tienen prioridad sobre las reglas especificadas en el directorio de configuración de QtProject. A su vez, estas reglas pueden ser sobrescritas por las del archivo de configuración especificado por QT_LOGGING_CONF, y las establecidas por QT_LOGGING_RULES.

El orden de evaluación es el siguiente:

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

El archivo QtProject/qtlogging.ini se busca en todos los directorios devueltos por QStandardPaths::GenericConfigLocation.

Configure la variable de entorno QT_LOGGING_DEBUG para saber desde dónde se cargan sus reglas de registro.

Instalación de un filtro personalizado

Como alternativa de nivel inferior a las reglas de texto, también puede implementar un filtro personalizado a través de installFilter(). En este caso se ignoran todas las reglas de filtrado.

Impresión de la categoría

Utilice el marcador de posición %{category} para imprimir la categoría en el manejador de mensajes por defecto:

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

Miembro Tipo Documentación

QLoggingCategory::CategoryFilter

Este es un typedef para un puntero a una función con la siguiente firma:

void myCategoryFilter(QLoggingCategory *);

Una función con esta firma puede instalarse con installFilter().

Documentación de funciones miembro

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

Construye un objeto QLoggingCategory con el nombre category, y habilita todos los mensajes con tipos al menos tan detallados como enableForLevel, que por defecto es QtDebugMsg (que habilita todas las categorías).

Si category es nullptr, se utiliza el nombre de categoría "default".

Nota: category debe mantenerse válido durante la vida de este objeto. Utilizar una cadena literal para ello es la forma habitual de conseguirlo.

[noexcept] QLoggingCategory::~QLoggingCategory()

Destruye un objeto QLoggingCategory.

const char *QLoggingCategory::categoryName() const

Devuelve el nombre de la categoría.

[static] QLoggingCategory *QLoggingCategory::defaultCategory()

Devuelve un puntero a la categoría global "default" que es utilizada, por ejemplo, por qDebug(), qInfo(), qWarning(), qCritical(), o qFatal().

Nota: El puntero devuelto puede ser nulo durante la destrucción de objetos estáticos. Además, no delete este puntero, ya que la propiedad de la categoría no se transfiere.

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

Controla cómo se configuran las categorías de registro.

Instala una función filter que se utiliza para determinar qué categorías y tipos de mensajes deben habilitarse. Si filter es nullptr, se restablece el filtro de mensajes por defecto. Devuelve un puntero al filtro previamente instalado.

Cada objeto QLoggingCategory que ya existe se pasa al filtro antes de que installFilter() regrese, y el filtro es libre de cambiar la configuración de cada categoría con setEnabled(). Cualquier categoría que no cambie conservará la configuración que le dio el filtro anterior, por lo que el nuevo filtro no necesita delegar en el filtro anterior durante esta pasada inicial por las categorías existentes.

Cualquier nueva categoría que se añada más tarde se pasará al nuevo filtro; un filtro que sólo quiera modificar la configuración de unas pocas categorías, en lugar de anular completamente la política de registro, puede pasar primero la nueva categoría al filtro anterior, para darle su configuración estándar, y luego modificarla como desee, si es una de las categorías de interés específico para el filtro. El código que instala el nuevo filtro puede registrar el retorno de installFilter() para que el filtro lo utilice en esas llamadas posteriores.

Cuando defina su filtro, tenga en cuenta que puede ser llamado desde diferentes hilos; pero nunca concurrentemente. Este filtro no puede llamar a ninguna función estática desde QLoggingCategory.

Ejemplo:

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

instalado (en main(), por ejemplo) por

oldCategoryFilter = QLoggingCategory::installFilter(myCategoryFilter);

Alternativamente, puede configurar el filtro por defecto a través de setFilterRules().

bool QLoggingCategory::isCriticalEnabled() const

Devuelve true si se deben mostrar mensajes críticos para esta categoría; false en caso contrario.

Nota: La macro qCCritical() ya realiza esta comprobación antes de ejecutar cualquier código. Sin embargo, llamar a este método puede ser útil para evitar la costosa generación de datos sólo para la salida de depuración.

bool QLoggingCategory::isDebugEnabled() const

Devuelve true si se deben mostrar mensajes de depuración para esta categoría; false en caso contrario.

Nota: La macro qCDebug() ya realiza esta comprobación antes de ejecutar cualquier código. Sin embargo, llamar a este método puede ser útil para evitar la costosa generación de datos sólo para la salida de depuración.

bool QLoggingCategory::isEnabled(QtMsgType msgtype) const

Devuelve true si se debe mostrar un mensaje del tipo msgtype para la categoría; false en caso contrario.

bool QLoggingCategory::isInfoEnabled() const

Devuelve true si se deben mostrar mensajes informativos para esta categoría; false en caso contrario.

Nota: La macro qCInfo() ya realiza esta comprobación antes de ejecutar cualquier código. Sin embargo, llamar a este método puede ser útil para evitar la costosa generación de datos sólo para la salida de depuración.

bool QLoggingCategory::isWarningEnabled() const

Devuelve true si se deben mostrar mensajes de advertencia para esta categoría; false en caso contrario.

Nota: La macro qCWarning() ya realiza esta comprobación antes de ejecutar cualquier código. Sin embargo, llamar a este método puede ser útil para evitar la costosa generación de datos sólo para la salida de depuración.

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

Cambia el tipo de mensaje type para la categoría a enable.

Este método está pensado para usarse sólo desde dentro de un filtro instalado con installFilter(). Para una visión general de cómo configurar categorías globalmente, vea Configuring Categories.

Nota: QtFatalMsg no puede modificarse; siempre permanecerá como true.

Véase también isEnabled().

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

Configura qué categorías y tipos de mensajes deben habilitarse a través de un conjunto de rules.

Ejemplo:

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

Nota: Las reglas pueden ser ignoradas si se instala un filtro de categorías personalizado con installFilter(), o si el usuario ha definido la variable de entorno QT_LOGGING_CONF o QT_LOGGING_RULES.

QLoggingCategory &QLoggingCategory::operator()()

Devuelve el objeto en sí. Esto permite tanto: una variable QLoggingCategory, como un método de fábrica que devuelve un QLoggingCategory, para ser utilizado en qCDebug(), qCWarning(), qCCritical(), o qCFatal() macros.

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

Devuelve el objeto en sí. Esto permite utilizar tanto una variable QLoggingCategory como un método de fábrica que devuelve un objeto QLoggingCategory en las macros qCDebug(), qCWarning(), qCCritical() o qCFatal().

Documentación de macros

[since 6.5] Q_DECLARE_EXPORTED_LOGGING_CATEGORY(name, EXPORT_MACRO)

Declara una categoría de registro name. La macro se puede utilizar para declarar una categoría de registro común compartida en diferentes partes del programa.

Funciona exactamente igual que Q_DECLARE_LOGGING_CATEGORY(). Sin embargo, la categoría de registro declarada por esta macro se califica adicionalmente con EXPORT_MACRO. Esto resulta útil si la categoría de registro debe exportarse desde una biblioteca dinámica.

Por ejemplo:

Q_DECLARE_EXPORTED_LOGGING_CATEGORY(lcCore, LIB_EXPORT_MACRO)

Esta macro debe utilizarse fuera de una clase o función.

Esta macro se introdujo en Qt 6.5.

Véase también Q_LOGGING_CATEGORY() y Q_DECLARE_LOGGING_CATEGORY().

Q_DECLARE_LOGGING_CATEGORY(name)

Declara una categoría de registro name. La macro puede usarse para declarar una categoría de registro común compartida en diferentes partes del programa.

Esta macro debe utilizarse fuera de una clase o método.

Véase también Q_LOGGING_CATEGORY() y Q_DECLARE_EXPORTED_LOGGING_CATEGORY().

Q_LOGGING_CATEGORY(name, string)

Define una categoría de registro name, y la hace configurable bajo el identificador string. Por defecto, todos los tipos de mensajes están habilitados.

Sólo una unidad de traducción en una biblioteca o ejecutable puede definir una categoría con un nombre específico. El objeto QLoggingCategory definido implícitamente se crea en el primer uso, de forma segura para los hilos.

Esta macro debe utilizarse fuera de una clase o método.

Véase también Q_DECLARE_LOGGING_CATEGORY() y Q_DECLARE_EXPORTED_LOGGING_CATEGORY().

Q_LOGGING_CATEGORY(name, string, msgType)

Define una categoría de registro name, y la hace configurable bajo el identificador string. Por defecto, los mensajes de QtMsgType msgType y más severos están habilitados, los tipos con una severidad menor están deshabilitados.

Sólo una unidad de traducción en una biblioteca o ejecutable puede definir una categoría con un nombre específico. El objeto QLoggingCategory definido implícitamente se crea en el primer uso, de forma segura para los hilos.

Esta macro debe utilizarse fuera de una clase o método.

Véase también Q_DECLARE_LOGGING_CATEGORY().

[since 6.9] Q_STATIC_LOGGING_CATEGORY(name, string)

Define una categoría de registro estática name, y la hace configurable bajo el identificador string. Por defecto, todos los tipos de mensajes están habilitados.

La categoría de registro se crea utilizando el cualificador static para que sólo se pueda acceder a ella en la misma unidad de traducción. Esto evita choques accidentales de símbolos.

El objeto implícitamente definido QLoggingCategory se crea en el primer uso, de forma segura para los hilos.

Esta macro debe utilizarse fuera de una clase o método.

Esta macro se introdujo en Qt 6.9.

Véase también Q_LOGGING_CATEGORY().

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

Define una categoría de registro estática name, y la hace configurable bajo el identificador string. Por defecto, los mensajes de QtMsgType msgType y más severos están habilitados, los tipos con una severidad menor están deshabilitados.

La categoría de registro se crea utilizando el cualificador static para que sólo se pueda acceder a ella en la misma unidad de traducción. Esto evita choques accidentales de símbolos.

El objeto implícitamente definido QLoggingCategory se crea en el primer uso, de forma segura para los hilos.

Esta macro debe utilizarse fuera de una clase o método.

Esta macro se introdujo en Qt 6.9.

Véase también Q_LOGGING_CATEGORY().

qCCritical(category)

Devuelve un flujo de salida para mensajes críticos en la categoría de registro, category.

La macro se expande a código que comprueba si QLoggingCategory::isCriticalEnabled() se evalúa como true. Si es así, los argumentos del flujo se procesan y se envían al gestor de mensajes.

Ejemplo:

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

Nota: Si la salida crítica para una categoría en particular no está habilitada, los argumentos no serán procesados, así que no confíe en ningún efecto secundario.

Véase también QDebug::qCritical().

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

Registra un mensaje crítico, message, en la categoría de registro, category. message puede contener marcadores de posición que se sustituirán por argumentos adicionales, de forma similar a la función printf() de C.

Ejemplo:

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

Nota: Si la salida crítica para una categoría particular no está habilitada, los argumentos no serán procesados, así que no confíe en ningún efecto secundario.

Véase también qCritical(const char *, ...).

qCDebug(category)

Devuelve un flujo de salida para mensajes de depuración en la categoría de registro, category.

La macro se expande a código que comprueba si QLoggingCategory::isDebugEnabled() se evalúa como true. Si es así, los argumentos del flujo se procesan y se envían al gestor de mensajes.

Ejemplo:

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

Nota: Los argumentos no se procesan si la salida de depuración para ese category no está habilitada, así que no confíe en ningún efecto secundario.

Véase también QDebug::qDebug().

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

Registra un mensaje de depuración, message, en la categoría de registro, category. message puede contener marcadores de posición que se sustituirán por argumentos adicionales, de forma similar a la función printf() de C.

Ejemplo:

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

Nota: Los argumentos no se procesan si la salida de depuración para ese category no está activada, así que no confíe en ningún efecto secundario.

Véase también qDebug(const char *, ...).

[since 6.5] qCFatal(category)

Devuelve un flujo de salida para mensajes fatales en la categoría de registro, category.

Si está utilizando el gestor de mensajes por defecto, el flujo devuelto abortará para crear un volcado del núcleo. En Windows, para construcciones de depuración, esta función informará de un _CRT_ERROR que le permitirá conectar un depurador a la aplicación.

Ejemplo:

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

Esta macro fue introducida en Qt 6.5.

Véase también QDebug::qFatal().

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

Registra un mensaje fatal, message, en la categoría de registro, category. message puede contener marcadores de posición que se sustituirán por argumentos adicionales, de forma similar a la función printf() de C.

Ejemplo:

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

Si está utilizando el gestor de mensajes por defecto, esta función abortará para crear un volcado del núcleo. En Windows, para construcciones de depuración, esta función reportará un _CRT_ERROR permitiéndole conectar un depurador a la aplicación.

Esta macro se introdujo en Qt 6.5.

Ver también qFatal(const char *, ...).

qCInfo(category)

Devuelve un flujo de salida para mensajes informativos en la categoría de registro, category.

La macro se expande a código que comprueba si QLoggingCategory::isInfoEnabled() se evalúa como true. Si es así, los argumentos del flujo se procesan y se envían al gestor de mensajes.

Ejemplo:

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

Nota: Si la salida de depuración para una categoría en particular no está habilitada, los argumentos no serán procesados, así que no confíe en ningún efecto secundario.

Véase también QDebug::qInfo().

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

Registra un mensaje informativo, message, en la categoría de registro, category. message puede contener marcadores de posición que se sustituirán por argumentos adicionales, de forma similar a la función printf() de C.

Ejemplo:

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

Nota: Si la salida de depuración para una categoría en particular no está habilitada, los argumentos no serán procesados, así que no confíe en ningún efecto secundario.

Véase también qInfo(const char *, ...).

qCWarning(category)

Devuelve un flujo de salida para mensajes de advertencia en la categoría de registro, category.

La macro se expande a código que comprueba si QLoggingCategory::isWarningEnabled() se evalúa como true. Si es así, los argumentos del flujo se procesan y se envían al gestor de mensajes.

Ejemplo:

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

Nota: Si la salida de avisos para una categoría en particular no está habilitada, los argumentos no serán procesados, así que no confíe en ningún efecto secundario.

Véase también QDebug::qWarning().

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

Registra un mensaje de advertencia, message, en la categoría de registro, category. message puede contener marcadores de posición que se sustituirán por argumentos adicionales, de forma similar a la función printf() de C.

Ejemplo:

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

Nota: Si la salida de advertencia para una categoría en particular no está habilitada, los argumentos no serán procesados, así que no confíe en ningún efecto secundario.

Véase también 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.