QLoggingCategory Class
La clase QLoggingCategory representa una categoría o «área» dentro de la infraestructura de registro. Más información...
| Encabezado: | #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 seguras para subprocesos.
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 se puede configurar para habilitar o deshabilitar el registro de mensajes según el 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, utiliza uno de estos métodos: isDebugEnabled(), isInfoEnabled(), isWarningEnabled() y isCriticalEnabled().
Todos los objetos están pensados para ser configurados mediante un registro común, tal y como se describe en Configuring Categories. Diferentes objetos también pueden representar la misma categoría. Por lo tanto, no se recomienda exportar objetos más allá de los límites de los módulos, manipular los objetos directamente ni heredar de QLoggingCategory.
Creación de objetos de categoría
Las macros Q_DECLARE_LOGGING_CATEGORY() y Q_LOGGING_CATEGORY() permiten declarar y crear cómodamente objetos de tipo 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 más allá de los límites de la biblioteca.
Los nombres de las categorías son de texto libre; para configurar categorías mediante Logging Rules, sus nombres deben seguir esta convención:
- Utiliza únicamente letras y números.
- Utiliza puntos para estructurar las categorías en áreas comunes.
- Evita los nombres de categoría: `
debug`, `info`, `warning` y `critical`. - Los nombres de categorías con el prefijo «
qt» están reservados exclusivamente para los módulos Qt.
Los objetos QLoggingCategory definidos implícitamente mediante Q_LOGGING_CATEGORY() se crean en el momento de su primer uso, de forma segura para los subprocesos.
Comprobación de la configuración de la categoría
QLoggingCategory proporciona isDebugEnabled(), isInfoEnabled(), isWarningEnabled(), isCriticalEnabled(), así como isEnabled() para comprobar si los mensajes de un tipo determinado deben registrarse en el registro.
Las macros qCDebug(), qCWarning() y qCCritical() impiden que se evalúen los argumentos si los tipos de mensaje correspondientes no están habilitados para la categoría, por lo que no es necesario realizar una comprobación explícita:
// usbEntries() will only be called if driverUsb category is enabled
qCDebug(driverUsb) << "devices: " << usbEntries();Configuración predeterminada de la categoría
Tanto el constructor de `QLoggingCategory` como la macro ` Q_LOGGING_CATEGORY()` aceptan un argumento opcional ` QtMsgType `, que desactiva todos los tipos de mensaje con una gravedad inferior. 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. Solo las categorías internas de Qt que comienzan por qt se tratan de forma diferente: en este caso, de forma predeterminada solo se registran los mensajes de tipo QtInfoMsg, QtWarningMsg, QtCriticalMsg y QFatalMsg.
Nota: Las categoríasde registro no se ven afectadas por la configuración de compilación de C++. Es decir, el hecho de que se muestren los mensajes no varía en función de si el código se compila con símbolos de depuración («compilación de depuración»), optimizaciones («compilación de lanzamiento») o cualquier otra combinación.
Configuración de categorías
Puedes 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 te permiten habilitar o deshabilitar el registro de categorías de forma flexible. Las reglas se especifican en formato de texto, donde cada línea debe tener el siguiente formato:
<category>[.<type>] = true|false<category> es el nombre de la categoría, que puede incluir « * » como comodín para el primer o el último carácter, o en ambas posiciones. El valor opcional « <type> » debe ser « debug », « info », « warning » o « critical ». Las líneas que no se ajusten a este esquema se ignoran.
Las reglas se evalúan en el orden en que aparecen en el texto, de la primera a la última. Es decir, si dos reglas se aplican a una categoría o tipo, se aplica la regla que aparece en último lugar.
Las reglas se pueden configurar mediante la función ` 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=trueLas reglas de registro también se pueden especificar en una variable de entorno QT_LOGGING_RULES; además, se pueden separar varias reglas mediante punto y coma:
QT_LOGGING_RULES=*.debug=false;driver.usb.debug=trueLas reglas establecidas mediante setFilterRules() tienen prioridad sobre las 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 por las establecidas mediante QT_LOGGING_RULES.
El orden de evaluación es el siguiente:
- [QLibraryInfo::DataPath]/qtlogging.ini
- QtProject/qtlogging.ini
- setFilterRules()
QT_LOGGING_CONFQT_LOGGING_RULES
El archivo QtProject/qtlogging.ini se busca en todos los directorios devueltos por QStandardPaths::GenericConfigLocation.
Configura la variable de entorno QT_LOGGING_DEBUG para averiguar desde dónde se cargan tus reglas de registro.
Instalación de un filtro personalizado
Como alternativa de nivel inferior a las reglas de texto, también puedes implementar un filtro personalizado mediante ` installFilter()`. En este caso, se ignoran todas las reglas de filtro.
Impresión de la categoría
Utiliza el marcador de posición %{category} para mostrar la categoría en el gestor de mensajes predeterminado:
qSetMessagePattern("%{category} %{message}");Documentación sobre tipos de miembro
QLoggingCategory::CategoryFilter
Se trata de un `typedef` para un puntero a una función con la siguiente firma:
void myCategoryFilter(QLoggingCategory *);Una función con esta firma se puede instalar mediante ` installFilter()`.
Documentación de la función miembro
[explicit] QLoggingCategory::QLoggingCategory(const char *category, QtMsgType enableForLevel = QtDebugMsg)
Crea un objeto `QLoggingCategory` con el nombre ` category ` proporcionado y habilita todos los mensajes con un nivel de detalle al menos igual al de ` enableForLevel`, cuyo valor por defecto es ` QtDebugMsg ` (lo 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 toda la vida útil de este objeto. La forma habitual de lograrlo es utilizar una cadena literal.
[noexcept] QLoggingCategory::~QLoggingCategory()
Elimina 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 utilizan, por ejemplo, las funciones qDebug(), qInfo(), qWarning(), qCritical() o qFatal().
Nota: El puntero devuelto puede ser nulo durante la destrucción de objetos estáticos. Además, no se debe llamar a ` delete ` con 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 estar habilitados. Si ` filter ` es ` nullptr`, se restablece el filtro de mensajes predeterminado. Devuelve un puntero al filtro instalado anteriormente.
Todos los objetos ` QLoggingCategory ` que ya existan se pasan al filtro antes de que ` installFilter() ` devuelva un valor, y el filtro es libre de modificar la configuración de cada categoría mediante ` setEnabled()` (). Cualquier categoría que no modifique conservará la configuración que le asignó el filtro anterior, por lo que el nuevo filtro no necesita delegar en el filtro anterior durante esta primera pasada por las categorías existentes.
Cualquier categoría nueva que se añada posteriormente se pasará al nuevo filtro; un filtro cuyo único objetivo sea ajustar la configuración de unas pocas categorías seleccionadas, en lugar de anular por completo la política de registro, puede pasar primero la nueva categoría al filtro anterior, para que este le asigne su configuración estándar, y luego ajustarla según se desee, si se trata de una de las categorías de interés específico para el filtro. El código que instala el nuevo filtro puede registrar el valor devuelto por installFilter() para que el filtro lo utilice en llamadas posteriores.
Al definir el filtro, ten en cuenta que puede ser invocado desde diferentes subprocesos, pero nunca de forma simultánea. Este filtro no puede llamar a ninguna función estática de 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) mediante
oldCategoryFilter = QLoggingCategory::installFilter(myCategoryFilter);Como alternativa, puedes configurar el filtro predeterminado mediante ` setFilterRules()` ().
bool QLoggingCategory::isCriticalEnabled() const
Devuelve ` true ` si deben mostrarse mensajes críticos para esta categoría; en caso contrario, devuelve ` false `.
Nota: La macro qCCritical() ya realiza esta comprobación antes de ejecutar cualquier código. Sin embargo, llamar a este método puede resultar útil para evitar la costosa generación de datos destinada exclusivamente a la salida de depuración.
bool QLoggingCategory::isDebugEnabled() const
Devuelve ` true ` si deben mostrarse mensajes de depuración para esta categoría; en caso contrario, devuelve ` false `.
Nota: La macro qCDebug() ya realiza esta comprobación antes de ejecutar cualquier código. Sin embargo, llamar a este método puede resultar útil para evitar la costosa generación de datos destinados exclusivamente a la salida de depuración.
bool QLoggingCategory::isEnabled(QtMsgType msgtype) const
Devuelve « true » si debe mostrarse un mensaje de tipo « msgtype » para esa categoría; en caso contrario, devuelve « false ».
bool QLoggingCategory::isInfoEnabled() const
Devuelve ` true ` si deben mostrarse mensajes informativos para esta categoría; en caso contrario, devuelve ` false `.
Nota: La macro qCInfo() ya realiza esta comprobación antes de ejecutar cualquier código. Sin embargo, llamar a este método puede resultar útil para evitar la costosa generación de datos destinados exclusivamente a la salida de depuración.
bool QLoggingCategory::isWarningEnabled() const
Devuelve ` true ` si deben mostrarse mensajes de advertencia para esta categoría; en caso contrario, devuelve ` false `.
Nota: La macro qCWarning() ya realiza esta comprobación antes de ejecutar cualquier código. Sin embargo, llamar a este método puede resultar útil para evitar la costosa generación de datos destinada exclusivamente a la salida de depuración.
void QLoggingCategory::setEnabled(QtMsgType type, bool enable)
Cambia el tipo de mensaje « type » de la categoría por « enable ».
Este método está pensado para utilizarse únicamente desde el interior de un filtro instalado con installFilter(). Para obtener una visión general sobre cómo configurar las categorías de forma global, consulta Configuring Categories.
Nota: QtFatalMsg no se puede modificar; siempre seguirá siendo true.
Véase también isEnabled().
[static] void QLoggingCategory::setFilterRules(const QString &rules)
Configura qué categorías y tipos de mensajes deben estar habilitados mediante un conjunto de rules.
Ejemplo:
QLoggingCategory::setFilterRules(QStringLiteral("driver.usb.debug=true"));Nota: Las reglas podrían ignorarse 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 propio objeto. Esto permite que tanto una variable ` QLoggingCategory ` como un método de fábrica que devuelva un ` QLoggingCategory` se puedan utilizar en las macros ` qCDebug()`, ` qCWarning()`, ` qCCritical()` o ` qCFatal()`.
const QLoggingCategory &QLoggingCategory::operator()() const
Devuelve el propio objeto. Esto permite que tanto una variable ` QLoggingCategory ` como un método de fábrica que devuelva un ` QLoggingCategory` se puedan utilizar en las macros ` qCDebug()`, ` qCWarning()`, ` qCCritical()` o ` qCFatal()`.
Documentación de las 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 lleva además el calificador EXPORT_MACRO. Esto resulta útil si es necesario exportar la categoría de registro 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 se puede utilizar para declarar una categoría de registro común que se comparte en diferentes partes del programa.
Esta macro debe utilizarse fuera de una clase o un 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 permite configurarla mediante el identificador string. Por defecto, todos los tipos de mensajes están habilitados.
Solo una unidad de traducción de una biblioteca o un ejecutable puede definir una categoría con un nombre específico. El objeto QLoggingCategory, definido de forma implícita, se crea la primera vez que se utiliza, de forma segura para los subprocesos.
Esta macro debe utilizarse fuera de una clase o un 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 permite configurarla mediante el identificador string. Por defecto, están habilitados los mensajes de QtMsgType, msgType y de gravedad superior; los de menor gravedad están deshabilitados.
Solo una unidad de traducción de una biblioteca o un ejecutable puede definir una categoría con un nombre específico. El objeto QLoggingCategory, definido implícitamente, se crea la primera vez que se utiliza, de forma segura para los subprocesos.
Esta macro debe utilizarse fuera de una clase o un 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 permite configurarla mediante el identificador string. De forma predeterminada, todos los tipos de mensajes están habilitados.
La categoría de registro se crea utilizando el calificador « static », de modo que solo se puede acceder a ella desde la misma unidad de traducción. Esto evita conflictos accidentales entre símbolos.
El objeto QLoggingCategory, definido de forma implícita, se crea la primera vez que se utiliza, de forma segura para los subprocesos.
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 permite configurarla mediante el identificador « string ». De forma predeterminada, están habilitados los mensajes de « QtMsgType », « msgType » y de gravedad superior; los de menor gravedad están deshabilitados.
La categoría de registro se crea utilizando el calificador static, de modo que solo se puede acceder a ella en la misma unidad de traducción. Esto evita conflictos accidentales entre símbolos.
El objeto ` QLoggingCategory `, definido de forma implícita, se crea la primera vez que se utiliza, de forma segura para subprocesos.
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 los mensajes críticos de la categoría de registro « category ».
La macro se expande en código que comprueba si QLoggingCategory::isCriticalEnabled() da como resultado 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 concreta no está habilitada, los argumentos no se procesarán, por lo que no debes confiar 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 concreta no está habilitada, los argumentos no se procesarán, por lo que no se debe confiar en ningún efecto secundario.
Véase también qCritical(const char *, ...).
qCDebug(category)
Devuelve un flujo de salida para los mensajes de depuración de la categoría de registro « category ».
La macro se expande en 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 gestionador 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 esa categoría « category » no está habilitada, por lo que no debes confiar 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á habilitada, por lo que no debes confiar en ningún efecto secundario.
Véase también ` qDebug(const char *, ...)`.
[since 6.5] qCFatal(category)
Devuelve un flujo de salida para los mensajes fatales de la categoría de registro « category ».
Si se utiliza el controlador de mensajes predeterminado, el flujo devuelto se interrumpirá para generar un volcado de memoria. En Windows, para las compilaciones de depuración, esta función informará de un « _CRT_ERROR », lo que permite conectar un depurador a la aplicación.
Ejemplo:
QLoggingCategory category("driver.usb");
qCFatal(category) << "a fatal message. Program will be terminated!";Esta macro se introdujo 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 utilizas el gestor de mensajes predeterminado, esta función se interrumpirá para crear un volcado de memoria. En Windows, para compilaciones de depuración, esta función informará de un « _CRT_ERROR », lo que te permitirá conectar un depurador a la aplicación.
Esta macro se introdujo en Qt 6.5.
Véase también qFatal(const char *, ...).
qCInfo(category)
Devuelve un flujo de salida para mensajes informativos de la categoría de registro « category ».
La macro se expande en código que comprueba si QLoggingCategory::isInfoEnabled() da como resultado 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 concreta no está habilitada, los argumentos no se procesarán, por lo que no debes confiar 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 concreta no está habilitada, los argumentos no se procesarán, por lo que no se debe confiar en ningún efecto secundario.
Véase también qInfo(const char *, ...).
qCWarning(category)
Devuelve un flujo de salida para los mensajes de advertencia de la categoría de registro « category ».
La macro se expande en código que comprueba si QLoggingCategory::isWarningEnabled() da como resultado 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 advertencias para una categoría concreta no está habilitada, los argumentos no se procesarán, por lo que no debes confiar 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 advertencias para una categoría concreta no está habilitada, los argumentos no se procesarán, por lo que no debes confiar 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.