QFlags Class
template <typename Enum> class QFlagsLa clase QFlags ofrece una forma segura en cuanto a tipos de almacenar combinaciones «OR» de valores de enumeración. Más información...
| Encabezado: | #include <QFlags> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Heredado de: | QtPrivate::QFlagsStorageHelper |
Tipos públicos
Funciones públicas
| QFlags() | |
| QFlags(Enum flags) | |
| QFlags(QFlag flag) | |
| QFlags(std::initializer_list<Enum> flags) | |
(since 6.9) | QFlags(std::in_place_t, QFlags<T>::Int flags) |
| QFlags(const QFlags<T> &other) | |
| QFlags<T> & | setFlag(Enum flag, bool on = true) |
(since 6.2) bool | testAnyFlag(Enum flag) const |
(since 6.2) bool | testAnyFlags(QFlags<T> flags) const |
| bool | testFlag(Enum flag) const |
(since 6.2) bool | testFlags(QFlags<T> flags) const |
(since 6.2) QFlags<T>::Int | toInt() const |
| operator QFlags<T>::Int() const | |
| bool | operator!() const |
| QFlags<T> | operator&(int mask) const |
| QFlags<T> | operator&(Enum mask) const |
(since 6.2) QFlags<T> | operator&(QFlags<T> mask) const |
| QFlags<T> | operator&(uint mask) const |
| QFlags<T> & | operator&=(int mask) |
| QFlags<T> & | operator&=(Enum mask) |
(since 6.2) QFlags<T> & | operator&=(QFlags<T> mask) |
| QFlags<T> & | operator&=(uint mask) |
| int & | operator=(const QFlags<T> &other) |
| QFlags<T> | operator^(QFlags<T> other) const |
| QFlags<T> | operator^(Enum other) const |
| QFlags<T> & | operator^=(QFlags<T> other) |
| QFlags<T> & | operator^=(Enum other) |
| QFlags<T> | operator|(QFlags<T> other) const |
| QFlags<T> | operator|(Enum other) const |
| QFlags<T> & | operator|=(QFlags<T> other) |
| QFlags<T> & | operator|=(Enum other) |
| QFlags<T> | operator~() const |
Miembros públicos estáticos
(since 6.2) QFlags<T> | fromInt(QFlags<T>::Int i) |
Elementos no miembros relacionados
(since 6.2) size_t | qHash(QFlags<Enum> key, size_t seed = 0) |
(since 6.2) bool | operator!=(Enum lhs, QFlags<T> rhs) |
(since 6.2) bool | operator!=(QFlags<T> lhs, Enum rhs) |
(since 6.2) bool | operator!=(QFlags<T> lhs, QFlags<T> rhs) |
(since 6.2) bool | operator==(Enum lhs, QFlags<T> rhs) |
(since 6.2) bool | operator==(QFlags<T> lhs, Enum rhs) |
(since 6.2) bool | operator==(QFlags<T> lhs, QFlags<T> rhs) |
Macros
| Q_DECLARE_FLAGS(Flags, Enum) | |
| Q_DECLARE_OPERATORS_FOR_FLAGS(Flags) |
Descripción detallada
QFlags<ENUM> es una clase de plantilla en la que Enum es un tipo de enumeración. QFlags se utiliza en todo Qt para almacenar combinaciones de valores de enumeración.
El enfoque tradicional de C++ para almacenar combinaciones OR de valores de enumeración consiste en utilizar una variable de tipo ` int ` o ` uint `. El inconveniente de este enfoque es que no hay ningún tipo de comprobación de tipos; cualquier valor de enumeración puede combinarse mediante OR con cualquier otro valor de enumeración y pasarse a una función que acepte un ` int ` o un ` uint`.
Desde Qt 6.9, QFlags admite enumeraciones de 64 bits. Se recomienda utilizar tipos subyacentes explícitos (fijos) cuando se superen los 32 bits, para garantizar que ni la enumeración ni el tipo QFlags cambien de tamaño si se elimina un elemento de la enumeración. Además, algunos compiladores solo ampliarán el tipo ` enum ` por encima de los 32 bits si se especifican tipos subyacentes explícitos.
Qt::AlignmentFlagQt utiliza QFlags para proporcionar seguridad de tipos. Por ejemplo, el tipo ` Qt::Alignment ` es simplemente un `typedef` para `QFlags<XML-ph-0001@deepl.internal>`. ` QLabel::setAlignment()` toma un parámetro de tipo ` Qt::Alignment `, lo que significa que cualquier combinación de valores ` Qt::AlignmentFlag ` o ` { }` es válida:
label->setAlignment(Qt::AlignLeft | Qt::AlignTop);
label->setAlignment({ });Si intentas pasar un valor de otra enumeración o simplemente un entero distinto de 0, el compilador mostrará un error. Si necesitas convertir valores enteros a indicadores sin especificar el tipo, puedes utilizar el constructor explícito de QFlags como operador de conversión.
Si deseas utilizar QFlags para tus propios tipos de enumeración, utiliza Q_DECLARE_FLAGS() y Q_DECLARE_OPERATORS_FOR_FLAGS(). En este caso, Q_DECLARE_FLAGS() debe aparecer en el mismo ámbito (clase o espacio de nombres) que la enumeración correspondiente.
Ejemplo:
class MyClass_1
{
public:
enum Option {
NoOptions = 0x0,
ShowTabs = 0x1,
ShowAll = 0x2,
SqueezeBlank = 0x4
};
Q_DECLARE_FLAGS(Options, Option)
//...
};
Q_DECLARE_OPERATORS_FOR_FLAGS(MyClass_1::Options)A continuación, puedes utilizar el tipo ` MyClass::Options ` para almacenar combinaciones de valores ` MyClass::Option `.
Los indicadores y el sistema de metaobjetos
La macro ` Q_DECLARE_FLAGS()` no expone los indicadores al sistema de metaobjetos, por lo que no pueden ser utilizados por Qt Script ni editados en ` Qt Widgets Designer`. Para que los indicadores estén disponibles para estos fines, debe utilizarse la macro ` Q_FLAG`:
class MyClass_2
{
Q_OBJECT
public:
enum Option {
NoOptions = 0x0,
ShowTabs = 0x1,
ShowAll = 0x2,
SqueezeBlank = 0x4
};
Q_DECLARE_FLAGS(Options, Option)
Q_FLAG(Options)
//...
};
Q_DECLARE_OPERATORS_FOR_FLAGS(MyClass_2::Options)Convención de nomenclatura
Una convención de nomenclatura sensata para los tipos de enumeración y los tipos QFlags asociados consiste en dar un nombre en singular al tipo de enumeración (p. ej., ` Option`) y un nombre en plural al tipo QFlags (p. ej., ` Options`). Cuando se desee un nombre en singular para el tipo QFlags (p. ej., Alignment), se puede utilizar Flag como sufijo para el tipo de enumeración (p. ej., AlignmentFlag).
Documentación sobre tipos de miembros
[alias] QFlags::Int
Definición de tipo (typedef) para el tipo entero utilizado tanto para el almacenamiento como para la conversión implícita. Puede ser « qintXX » o « quintXX », dependiendo de si el tipo subyacente de la enumeración es con signo o sin signo y, a partir de Qt 6.9, del tamaño de la enumeración. Normalmente, será « qint32 » (int) o « quint32 » (unsigned).
QFlags::enum_type
Definición de tipo (typedef) para el tipo de plantilla de enumeración.
Documentación de las funciones de miembro
[constexpr noexcept default] QFlags::QFlags()
Crea un objeto QFlags sin ningún indicador activado.
[constexpr noexcept] QFlags::QFlags(Enum flags)
Crea un objeto QFlags que almacena el flags.
[constexpr noexcept] QFlags::QFlags(QFlag flag) requires (sizeof(Enum) == sizeof(int))
Crea un objeto QFlags inicializado con el número entero ` flag`.
El tipo ` QFlag ` es un tipo auxiliar. Al utilizarlo aquí en lugar de ` int`, nos aseguramos de que los valores de enumeración arbitrarios no puedan convertirse a un `QFlags`, mientras que los valores de enumeración sin tipo (es decir, los valores de ` int `) sí pueden.
Este constructor solo está disponible para tipos ` Enum ` de 32 bits. Para admitir todos los tamaños de enumeración, considera utilizar el constructor con ` std::in_place_t`.
[constexpr noexcept] QFlags::QFlags(std::initializer_list<Enum> flags)
Crea un objeto QFlags inicializado con todos los valores de flags combinados mediante el operador OR bit a bit.
Véase también operator|=() y operator|().
[constexpr noexcept, since 6.9] QFlags::QFlags(std::in_place_t, QFlags<T>::Int flags)
Crea un objeto QFlags inicializado con el número entero flags.
Esta función se introdujo en Qt 6.9.
[implicit] QFlags::QFlags(const QFlags<T> &other)
Crea una copia de other.
[static constexpr noexcept, since 6.2] QFlags<T> QFlags::fromInt(QFlags<T>::Int i)
Crea un objeto ` QFlags ` que representa el valor entero ` i`.
Esta función se introdujo en Qt 6.2.
[constexpr noexcept] QFlags<T> &QFlags::setFlag(Enum flag, bool on = true)
Establece el indicador « flag » si « on » es « true » o lo desactiva si « on » es « false ». Devuelve una referencia a este objeto.
[constexpr noexcept, since 6.2] bool QFlags::testAnyFlag(Enum flag) const
Devuelve ` true ` si alguna de las opciones activadas en ` flag ` también está activada en este objeto de opciones; en caso contrario, devuelve ` false`. Si en ` flag ` no hay ninguna opción activada, el valor devuelto será siempre ` false`.
Esta función se introdujo en Qt 6.2.
Véase también testFlag().
[constexpr noexcept, since 6.2] bool QFlags::testAnyFlags(QFlags<T> flags) const
Devuelve ` true ` si alguna de las opciones establecidas en ` flags ` también está establecida en este objeto de opciones; en caso contrario, devuelve ` false`. Si en ` flags ` no hay ninguna opción establecida, el valor devuelto será siempre ` false`.
Esta función se introdujo en Qt 6.2.
Véase también testFlags().
[constexpr noexcept] bool QFlags::testFlag(Enum flag) const
Devuelve « true » si está activada la bandera « flag »; en caso contrario, devuelve « false ».
Nota: si ` flag ` contiene varios bits a 1 (por ejemplo, si se trata de un enumerador igual a la operación OR bit a bit de otros enumeradores), esta función devolverá ` true ` si y solo si todos los bits de este objeto de indicadores están a 1. Por otro lado, si flag no contiene ningún bit a 1 (es decir, su valor como entero es 0), entonces esta función devolverá true si y solo si este objeto de indicadores tampoco tiene ningún bit a 1.
Véase también testAnyFlag().
[constexpr noexcept, since 6.2] bool QFlags::testFlags(QFlags<T> flags) const
Devuelve ` true ` si este objeto de indicadores coincide con el objeto ` flags` dado.
Si flags tiene alguna bandera activada, este objeto de banderas coincide exactamente si todas las banderas activadas en flags también lo están en este objeto de banderas. Por el contrario, cuando flags no tiene ninguna bandera activada, este objeto de banderas solo coincide si tampoco tiene ninguna bandera activada.
Esta función se introdujo en Qt 6.2.
Véase también testAnyFlags().
[constexpr noexcept, since 6.2] QFlags<T>::Int QFlags::toInt() const
Devuelve el valor almacenado en el objeto ` QFlags ` como un entero. Ten en cuenta que el entero devuelto puede ser con signo o sin signo, dependiendo de si el tipo subyacente de la enumeración es con signo o sin signo.
Esta función se introdujo en Qt 6.2.
Véase también Int.
[constexpr noexcept] QFlags::operator QFlags<T>::Int() const
Devuelve el valor almacenado en el objeto ` QFlags ` como un número entero.
Véase también Int.
[constexpr noexcept] bool QFlags::operator!() const
Devuelve « true » si no hay ningún indicador activado (es decir, si el valor almacenado por el objeto ` QFlags ` es 0); en caso contrario, devuelve « false ».
[constexpr noexcept] QFlags<T> QFlags::operator&(int mask) const
Devuelve un objeto ` QFlags ` que contiene el resultado de la operación AND bit a bit entre este objeto y ` mask`.
Este operador queda desactivado si se define la macro « QT_TYPESAFE_FLAGS ». Ten en cuenta que tampoco se amplía a 64 bits para los objetos « QFlags » de 64 bits: para la compatibilidad con 64 bits, utiliza la sobrecarga segura en cuanto al tipo.
Véase también operator&=(), operator|(), operator^() y operator~().
[constexpr noexcept] QFlags<T> QFlags::operator&(Enum mask) const
Esta es una función sobrecargada.
[constexpr noexcept, since 6.2] QFlags<T> QFlags::operator&(QFlags<T> mask) const
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.2.
[constexpr noexcept] QFlags<T> QFlags::operator&(uint mask) const
Este operador queda desactivado si se define la macro ` QT_TYPESAFE_FLAGS `. Ten en cuenta que tampoco se amplía a 64 bits para los ` QFlags ` de 64 bits: para la compatibilidad con 64 bits, utiliza la sobrecarga segura en cuanto al tipo.
Esta es una función sobrecargada.
[constexpr noexcept] QFlags<T> &QFlags::operator&=(int mask)
Realiza una operación AND bit a bit con ` mask ` y almacena el resultado en este objeto ` QFlags `. Devuelve una referencia a este objeto.
Este operador queda desactivado si se define la macro « QT_TYPESAFE_FLAGS ». Ten en cuenta que tampoco se amplía a 64 bits para los objetos « QFlags » de 64 bits: para la compatibilidad con 64 bits, utiliza la sobrecarga segura en cuanto al tipo.
Véase también operator&(), operator|=() y operator^=().
[constexpr noexcept] QFlags<T> &QFlags::operator&=(Enum mask)
Esta es una función sobrecargada.
[constexpr noexcept, since 6.2] QFlags<T> &QFlags::operator&=(QFlags<T> mask)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.2.
[constexpr noexcept] QFlags<T> &QFlags::operator&=(uint mask)
Este operador queda desactivado si se define la macro ` QT_TYPESAFE_FLAGS `. Ten en cuenta que tampoco se amplía a 64 bits para ` QFlags ` de 64 bits: para obtener compatibilidad con 64 bits, utiliza la sobrecarga segura para el tipo.
Esta es una función sobrecargada.
[implicit] int &QFlags::operator=(const QFlags<T> &other)
Asigna ` other ` a este objeto y devuelve una referencia a este objeto.
[constexpr noexcept] QFlags<T> QFlags::operator^(QFlags<T> other) const
Devuelve un objeto ` QFlags ` que contiene el resultado de la operación XOR bit a bit entre este objeto y ` other`.
Véase también operator^=(), operator&(), operator|() y operator~().
[constexpr noexcept] QFlags<T> QFlags::operator^(Enum other) const
Esta es una función sobrecargada.
[constexpr noexcept] QFlags<T> &QFlags::operator^=(QFlags<T> other)
Realiza una operación XOR bit a bit con other y almacena el resultado en este objeto QFlags. Devuelve una referencia a este objeto.
Véase también ` operator^()`, ` operator&=()` y ` operator|=()`.
[constexpr noexcept] QFlags<T> &QFlags::operator^=(Enum other)
Esta es una función sobrecargada.
[constexpr noexcept] QFlags<T> QFlags::operator|(QFlags<T> other) const
Devuelve un objeto ` QFlags ` que contiene el resultado de la operación OR bit a bit entre este objeto y ` other`.
Véase también operator|=(), operator^(), operator&() y operator~().
[constexpr noexcept] QFlags<T> QFlags::operator|(Enum other) const
Esta es una función sobrecargada.
[constexpr noexcept] QFlags<T> &QFlags::operator|=(QFlags<T> other)
Realiza una operación OR bit a bit con other y almacena el resultado en este objeto QFlags. Devuelve una referencia a este objeto.
Véanse también ` operator|()`, ` operator&=()` y ` operator^=()`.
[constexpr noexcept] QFlags<T> &QFlags::operator|=(Enum other)
Esta es una función sobrecargada.
[constexpr noexcept] QFlags<T> QFlags::operator~() const
Devuelve un objeto ` QFlags ` que contiene la negación bit a bit de este objeto.
Elementos no miembros relacionados
[constexpr noexcept, since 6.2] template <typename Enum> size_t qHash(QFlags<Enum> key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Esta función se introdujo en Qt 6.2.
[constexpr noexcept, since 6.2] bool operator!=(Enum lhs, QFlags<T> rhs)
[constexpr noexcept, since 6.2] bool operator!=(QFlags<T> lhs, Enum rhs)
[constexpr noexcept, since 6.2] bool operator!=(QFlags<T> lhs, QFlags<T> rhs)
Compara lhs y rhs para detectar si son desiguales; se considera que los dos argumentos son diferentes si no representan exactamente el mismo valor (máscara de bits).
Estas funciones se introdujeron en Qt 6.2.
[constexpr noexcept, since 6.2] bool operator==(Enum lhs, QFlags<T> rhs)
[constexpr noexcept, since 6.2] bool operator==(QFlags<T> lhs, Enum rhs)
[constexpr noexcept, since 6.2] bool operator==(QFlags<T> lhs, QFlags<T> rhs)
Comprueba si lhs y rhs son iguales; se considera que los dos argumentos son iguales si representan exactamente el mismo valor (máscara de bits).
Estas funciones se introdujeron en Qt 6.2.
Documentación de macros
Q_DECLARE_FLAGS(Flags, Enum)
La macro Q_DECLARE_FLAGS() se expande a
typedef QFlags<Enum> Flags;Enum es el nombre de un tipo enumerado existente, mientras que Flags es el nombre de la definición de tipo <Enum> de QFlags.
Consulte la documentación de QFlags para obtener más detalles.
Véase también Q_DECLARE_OPERATORS_FOR_FLAGS().
Q_DECLARE_OPERATORS_FOR_FLAGS(Flags)
La macro Q_DECLARE_OPERATORS_FOR_FLAGS() declara las funciones globales de operadores bit a bit operator|(), operator&(), operator^(), operator~() y sus formas de asignación: &=, |= y ^= para Flags, que es de tipo QFlags<T>.
Consulta la documentación de QFlags para obtener más detalles.
Véase también Q_DECLARE_FLAGS().
© 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.