QMetaType Class
La clase QMetaType gestiona los tipos con nombre en el sistema de metaobjetos. Más información...
| Encabezado: | #include <QMetaType> |
| 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.
Comparaciones de QMetaType
| Categoría | Tipos comparables |
|---|---|
| igualdad | QMetaType |
Tipos públicos
| enum | Type { Void, Bool, Int, UInt, Double, …, UnknownType } |
| enum | TypeFlag { NeedsConstruction, NeedsCopyConstruction, NeedsMoveConstruction, NeedsDestruction, RelocatableType, …, IsConst } |
| flags | TypeFlags |
Funciones públicas
(since 6.0) | QMetaType() |
| QMetaType(int typeId) | |
(since 6.0) qsizetype | alignOf() const |
(since 6.0) QPartialOrdering | compare(const void *lhs, const void *rhs) const |
| void * | construct(void *where, const void *copy = nullptr) const |
| void * | create(const void *copy = nullptr) const |
| bool | debugStream(QDebug &dbg, const void *rhs) |
| void | destroy(void *data) const |
| void | destruct(void *data) const |
(since 6.0) bool | equals(const void *lhs, const void *rhs) const |
| QMetaType::TypeFlags | flags() const |
(since 6.1) bool | hasRegisteredDataStreamOperators() const |
(since 6.0) bool | hasRegisteredDebugStreamOperator() const |
| int | id() const |
(since 6.5) bool | isCopyConstructible() const |
(since 6.5) bool | isDefaultConstructible() const |
(since 6.5) bool | isDestructible() const |
| bool | isEqualityComparable() const |
(since 6.5) bool | isMoveConstructible() const |
| bool | isOrdered() const |
| bool | isRegistered() const |
| bool | isValid() const |
| bool | load(QDataStream &stream, void *data) const |
| const QMetaObject * | metaObject() const |
| const char * | name() const |
(since 6.5) void | registerType() const |
| bool | save(QDataStream &stream, const void *data) const |
| qsizetype | sizeOf() const |
(since 6.6) QMetaType | underlyingType() const |
Miembros públicos estáticos
| bool | canConvert(QMetaType fromType, QMetaType toType) |
| bool | canView(QMetaType fromType, QMetaType toType) |
| bool | convert(QMetaType fromType, const void *from, QMetaType toType, void *to) |
| QMetaType | fromName(QByteArrayView typeName) |
| QMetaType | fromType() |
| bool | hasRegisteredConverterFunction(QMetaType fromType, QMetaType toType) |
| bool | hasRegisteredConverterFunction() |
| bool | hasRegisteredMutableViewFunction(QMetaType fromType, QMetaType toType) |
(since 6.0) bool | hasRegisteredMutableViewFunction() |
| bool | isRegistered(int type) |
| bool | registerConverter() |
| bool | registerConverter(To (From::*function)() const) |
| bool | registerConverter(To (From::*function)(bool *) const) |
| bool | registerConverter(UnaryFunction function) |
(since 6.0) bool | registerMutableView(To (From::*function)()) |
(since 6.0) bool | registerMutableView(UnaryFunction function) |
(since 6.0) bool | view(QMetaType fromType, void *from, QMetaType toType, void *to) |
Elementos no miembros relacionados
(since 6.4) size_t | qHash(QMetaType key, size_t seed = 0) |
| int | qMetaTypeId() |
| int | qRegisterMetaType() |
(since 6.5) int | qRegisterMetaType(QMetaType meta) |
| bool | operator!=(const QMetaType &lhs, const QMetaType &rhs) |
(since 6.5) QDebug | operator<<(QDebug d, QMetaType m) |
| bool | operator==(const QMetaType &lhs, const QMetaType &rhs) |
Macros
| Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE(Container) | |
| Q_DECLARE_METATYPE(Type) | |
| Q_DECLARE_OPAQUE_POINTER(PointerType) | |
| Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(Container) | |
| Q_DECLARE_SMART_POINTER_METATYPE(SmartPointer) |
Descripción detallada
Esta clase se utiliza como ayuda para la conversión de tipos en « QVariant » y en conexiones de señales y ranuras en cola. Asocia un nombre de tipo a un tipo para que pueda crearse y destruirse dinámicamente en tiempo de ejecución.
Los nombres de tipo se pueden registrar con `QMetaType` utilizando ` qRegisterMetaType()` o ` registerType()`. El registro no es necesario para la mayoría de las operaciones; solo se requiere para aquellas que intentan resolver un nombre de tipo en forma de cadena y convertirlo de nuevo en un objeto `QMetaType` o en el identificador del tipo. Entre ellas se incluyen algunas conexiones de señal-ranura de estilo antiguo que utilizan QObject::connect(), la lectura de tipos de usuario desde QDataStream hasta QVariant, o el enlace con otros lenguajes y mecanismos de IPC, como QML, D-Bus, JavaScript, etc.
El siguiente código asigna y destruye una instancia de MyClass por su nombre, lo que requiere que MyClass se haya registrado previamente:
QMetaType type = QMetaType::fromName("MyClass");
if (type.isValid()) {
void *myClassPtr = type.create();
//...
type.destroy(myClassPtr);
myClassPtr = nullptr;
}Si queremos que los operadores de flujo operator<<() y operator>>() funcionen con objetos de QVariant que almacenen tipos personalizados, el tipo personalizado debe proporcionar los operadores operator<<() y operator>>().
Véase también Q_DECLARE_METATYPE(), QVariant::setValue(), QVariant::value() y QVariant::fromValue().
Documentación sobre tipos de miembros
enum QMetaType::Type
Estos son los tipos integrados que admite QMetaType:
| Constante | Valor | Descripción |
|---|---|---|
QMetaType::Void | 43 | void |
QMetaType::Bool | 1 | bool |
QMetaType::Int | 2 | int |
QMetaType::UInt | 3 | unsigned int |
QMetaType::Double | 6 | double |
QMetaType::QChar | 7 | QChar |
QMetaType::QString | 10 | QString |
QMetaType::QByteArray | 12 | QByteArray |
QMetaType::Nullptr | 51 | std::nullptr_t |
QMetaType::VoidStar | 31 | void * |
QMetaType::Long | 32 | long |
QMetaType::LongLong | 4 | LongLong |
QMetaType::Short | 33 | short |
QMetaType::Char | 34 | char |
QMetaType::Char16 | 56 | char16_t |
QMetaType::Char32 | 57 | char32_t |
QMetaType::ULong | 35 | unsigned long |
QMetaType::ULongLong | 5 | ULongLong |
QMetaType::UShort | 36 | unsigned short |
QMetaType::SChar | 40 | signed char |
QMetaType::UChar | 37 | unsigned char |
QMetaType::Float | 38 | float |
QMetaType::Float16 | 63 | qfloat16 |
QMetaType::QObjectStar | 39 | QObject * |
QMetaType::QBitArray | 13 | QBitArray |
QMetaType::QBitmap | 0x1009 | QBitmap |
QMetaType::QBrush | 0x1002 | QBrush |
QMetaType::QByteArrayList | 49 | QByteArrayList |
QMetaType::QCborArray | 54 | QCborArray |
QMetaType::QCborMap | 55 | QCborMap |
QMetaType::QCborSimpleType | 52 | QCborSimpleType |
QMetaType::QCborValue | 53 | QCborValue |
QMetaType::QColor | 0x1003 | QColor |
QMetaType::QColorSpace | 0x1017 | QColorSpace (introducido en Qt 5.15) |
QMetaType::QCursor | 0x100a | QCursor |
QMetaType::QDate | 14 | QDate |
QMetaType::QDateTime | 16 | QDateTime |
QMetaType::QEasingCurve | 29 | QEasingCurve |
QMetaType::QFont | 0x1000 | QFont |
QMetaType::QIcon | 0x1005 | QIcon |
QMetaType::QImage | 0x1006 | QImage |
QMetaType::QJsonArray | 47 | QJsonArray |
QMetaType::QJsonDocument | 48 | QJsonDocument |
QMetaType::QJsonObject | 46 | QJsonObject |
QMetaType::QJsonValue | 45 | QJsonValue |
QMetaType::QKeySequence | 0x100b | QKeySequence |
QMetaType::QLine | 23 | QLine |
QMetaType::QLineF | 24 | QLineF |
QMetaType::QLocale | 18 | QLocale |
QMetaType::QMatrix4x4 | 0x1011 | QMatrix4x4 |
QMetaType::QModelIndex | 42 | QModelIndex |
QMetaType::QPalette | 0x1004 | QPaleta |
QMetaType::QPen | 0x100c | QPen |
QMetaType::QPersistentModelIndex | 50 | QPersistentModelIndex (introducido en Qt 5.5) |
QMetaType::QPixmap | 0x1001 | QPixmap |
QMetaType::QPoint | 25 | QPoint |
QMetaType::QPointF | 26 | QPointF |
QMetaType::QPolygon | 0x1007 | QPolygon |
QMetaType::QPolygonF | 0x1016 | QPolygonF |
QMetaType::QQuaternion | 0x1015 | QCuaternión |
QMetaType::QRect | 19 | QRect |
QMetaType::QRectF | 20 | QRectF |
QMetaType::QRegion | 0x1008 | QRegion |
QMetaType::QRegularExpression | 44 | QExpresiónRegular |
QMetaType::QSize | 21 | QSize |
QMetaType::QSizeF | 22 | QSizeF |
QMetaType::QSizePolicy | 0x2000 | QSizePolicy |
QMetaType::QStringList | 11 | QListaDeCadenas |
QMetaType::QTextFormat | 0x100e | QTextFormat |
QMetaType::QTextLength | 0x100d | QTextLength |
QMetaType::QTime | 15 | QTime |
QMetaType::QTransform | 0x1010 | QTransform |
QMetaType::QUrl | 17 | QUrl |
QMetaType::QUuid | 30 | QUuid |
QMetaType::QVariant | 41 | QVariant |
QMetaType::QVariantHash | 28 | QVariantHash |
QMetaType::QVariantList | 9 | QVariantList |
QMetaType::QVariantMap | 8 | QVariantMap |
QMetaType::QVariantPair | 58 | QVariantPair |
QMetaType::QVector2D | 0x1012 | QVector2D |
QMetaType::QVector3D | 0x1013 | QVector3D |
QMetaType::QVector4D | 0x1014 | QVector4D |
QMetaType::User | 65536 | Valor base para tipos de usuario |
QMetaType::UnknownType | 0 | Este identificador de tipo no es válido. Se devuelve desde ` QMetaType ` para los tipos que no están registrados |
Se pueden registrar tipos adicionales utilizando ` qRegisterMetaType()` o llamando a ` registerType()`.
Véase también type().
enum QMetaType::TypeFlag
flags QMetaType::TypeFlags
La enumeración describe los atributos de un tipo compatible con QMetaType.
| Constante | Valor | Descripción |
|---|---|---|
QMetaType::NeedsConstruction | 0x1 | Este tipo tiene un constructor por defecto. Si no se establece el indicador, las instancias se pueden inicializar de forma segura con memset a 0. |
QMetaType::NeedsCopyConstruction (since Qt 6.5) | 0x4000 | Este tipo tiene un constructor de copia no trivial. Si no se activa el indicador, las instancias se pueden copiar con `memcpy`. |
QMetaType::NeedsMoveConstruction (since Qt 6.5) | 0x8000 | Este tipo tiene un constructor de traslado no trivial. Si no se activa el indicador, las instancias se pueden trasladar con `memcpy`. |
QMetaType::NeedsDestruction | 0x2 | Este tipo tiene un destructor no trivial. Si no se activa el indicador, no es necesario llamar al destructor antes de descartar los objetos. |
QMetaType::RelocatableType | 0x4 | Una instancia de un tipo que tenga este atributo puede trasladarse de forma segura a una ubicación de memoria diferente utilizando memcpy. |
QMetaType::IsEnumeration | 0x10 | Este tipo es una enumeración. |
QMetaType::IsUnsignedEnumeration | 0x100 | Si el tipo es una enumeración, su tipo subyacente es de tipo sin signo. |
QMetaType::PointerToQObject | 0x8 | Este tipo es un puntero a una clase derivada de ` QObject`. |
QMetaType::IsPointer | 0x800 | Este tipo es un puntero a otro tipo. |
QMetaType::IsConst | 0x2000 | Indica que los valores de este tipo son inmutables; por ejemplo, porque son punteros a objetos const. Nota: Antes de Qt 6.5, las banderas NeedsConstruction y NeedsDestruction se establecían incorrectamente si el constructor de copia o el destructor no eran triviales (es decir, si el tipo no era trivial). |
Ten en cuenta que las banderas «Needs» pueden estar activadas, pero es posible que el metatipo no tenga un constructor de acceso público del tipo correspondiente ni un destructor de acceso público.
El tipo `TypeFlags` es un `typedef` para ` QFlags<TypeFlag>`. Almacena una combinación OR de valores de `TypeFlag`.
Documentación de las funciones miembro
[constexpr noexcept default, since 6.0] QMetaType::QMetaType()
Crea un objeto QMetaType predeterminado e inválido.
Esta función se introdujo en Qt 6.0.
[explicit] QMetaType::QMetaType(int typeId)
Crea un objeto `QMetaType` que contiene toda la información sobre el tipo ` typeId`.
[constexpr, since 6.0] qsizetype QMetaType::alignOf() const
Devuelve la alineación del tipo en bytes (es decir, `alignof(T)`, donde `T` es el tipo real para el que se construyó esta instancia de ` QMetaType `).
Esta función se suele utilizar junto con ` construct()` para llevar a cabo una gestión de bajo nivel de la memoria utilizada por un tipo.
Esta función se introdujo en Qt 6.0.
Véanse también ` QMetaType::construct()` y ` QMetaType::sizeOf()`.
[static] bool QMetaType::canConvert(QMetaType fromType, QMetaType toType)
Devuelve ` true ` si ` QMetaType::convert ` puede convertir de ` fromType ` a ` toType`. Ten en cuenta que esto se refiere principalmente a la capacidad de ejecutar la conversión, mientras que la conversión en sí misma puede fallar al intentarla (por ejemplo, al convertir un valor de punto flotante a un entero fuera de su rango).
La función registerConverter() se puede utilizar para registrar conversiones adicionales, ya sea entre un tipo integrado y uno no integrado, o entre dos tipos no integrados. Esta función devolverá true si se registra la ruta de conversión.
Qt admite las siguientes conversiones:
Otras conversiones admitidas incluyen las realizadas entre todos los tipos primitivos (int, float, bool, etc., incluidas todas las enumeraciones) y entre cualquier tipo de puntero y std::nullptr_t. Las enumeraciones también se pueden convertir a QString y QByteArray.
Si tanto fromType como toType son tipos derivados de QObject (o punteros a ellos), esta función también devolverá true si uno de los tipos deriva del otro. Es decir, devuelve «true» si se pudiera compilar static_cast<> del tipo descrito por fromType al tipo descrito por toType. La función convert() funciona como qobject_cast() y verifica el tipo dinámico del objeto al que apunta QVariant.
Una conversión desde un contenedor secuencial también devolverá «true» para esta función si toType es QVariantList.
Del mismo modo, una conversión desde un contenedor asociativo también devolverá «true» para esta función si toType es QVariantHash o QVariantMap.
Véanse también convert(), QMetaSequence::Iterable, Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(), QMetaAssociation::Iterable y Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE().
[static] bool QMetaType::canView(QMetaType fromType, QMetaType toType)
Devuelve ` true ` si ` QMetaType::view ` puede crear una vista mutable de tipo ` toType ` sobre el tipo ` fromType`.
La conversión entre punteros de tipos derivados de QObject devolverá «true» para esta función si una qobject_cast del tipo descrito por fromType al tipo descrito por toType se realizara con éxito.
Puedes crear una vista mutable de tipo QMetaSequence::Iterable sobre cualquier contenedor registrado con Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE().
Del mismo modo, se puede crear una vista mutable de tipo QMetaAssociation::Iterable en cualquier contenedor registrado con Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE().
Véase también ` convert()`, ` QMetaSequence::Iterable`, ` Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE()`, ` QMetaAssociation::Iterable` y ` Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE()`.
[since 6.0] QPartialOrdering QMetaType::compare(const void *lhs, const void *rhs) const
Compara los objetos de lhs y rhs para determinar su orden.
Devuelve QPartialOrdering::Unordered si la comparación no está admitida o si los valores no están ordenados. En caso contrario, devuelve QPartialOrdering::Less, QPartialOrdering::Equivalent o QPartialOrdering::Greater si lhs es menor que, igual que o mayor que rhs, respectivamente.
Ambos objetos deben ser del tipo descrito por este metatipo. Si lhs o rhs es nullptr, los valores no están ordenados. La comparación solo se admite si el operador «menor que» del tipo era visible para la declaración del metatipo.
Si el operador de igualdad del tipo también era visible, los valores solo se considerarán iguales si el operador de igualdad así lo indica. En ausencia de un operador de igualdad, cuando ninguno de los valores es menor que el otro, los valores se consideran iguales; si la igualdad también está disponible y dos de esos valores no son iguales, se consideran sin orden, al igual que los valores NaN (no es un número) de un tipo de punto flotante quedan fuera de su ordenación.
Nota: Si ningún operador «menor que» era visible para la declaración del metatipo, los valores no están ordenados aunque un operador de igualdad visible para la declaración los considere iguales: compare() == 0 solo coincide con equals() si el operador «menor que» era visible.
Esta función se introdujo en Qt 6.0.
Véase también equals() y isOrdered().
void *QMetaType::construct(void *where, const void *copy = nullptr) const
Crea un valor del tipo para el que se creó esta instancia de ` QMetaType ` en la memoria existente a la que apunta ` where`, que es una copia de ` copy`, y devuelve ` where`. Si ` copy ` es cero, el valor se crea de forma implícita.
Se trata de una función de bajo nivel para gestionar explícitamente la memoria utilizada para almacenar el tipo. Considera la posibilidad de llamar a create() si no necesitas este nivel de control (es decir, utiliza «new» en lugar de «placement new»).
Debes asegurarte de que where apunte a una ubicación donde se pueda almacenar el nuevo valor y de que where esté correctamente alineado. El tamaño del tipo se puede consultar llamando a sizeOf().
La regla general para la alineación es que un tipo se alinea a su límite natural, que es la menor potencia de 2 mayor que el tipo, a menos que dicha alineación sea mayor que la alineación máxima útil para la plataforma. A efectos prácticos, una alineación mayor que 2 * sizeof(void*) solo es necesaria para instrucciones especiales de hardware (por ejemplo, cargas y almacenamientos SSE alineados en x86).
[static] bool QMetaType::convert(QMetaType fromType, const void *from, QMetaType toType, void *to)
Convierte el objeto situado en from, de tipo fromType, al espacio preasignado en to, de tipo toType. Devuelve true si la conversión se ha realizado correctamente; en caso contrario, devuelve false.
Tanto from como to deben ser punteros válidos.
void *QMetaType::create(const void *copy = nullptr) const
Devuelve una copia de ` copy`, suponiendo que sea del tipo para el que se creó esta instancia de ` QMetaType `. Si ` copy ` es ` nullptr`, crea una instancia construida de forma predeterminada.
Véase también QMetaType::destroy().
bool QMetaType::debugStream(QDebug &dbg, const void *rhs)
Transmite el objeto de rhs al flujo de depuración dbg. Devuelve true si la operación se realiza correctamente; en caso contrario, devuelve false.
void QMetaType::destroy(void *data) const
Destruye el objeto « data », siempre que sea del tipo para el que se creó esta instancia de « QMetaType ».
Véase también QMetaType::create().
void QMetaType::destruct(void *data) const
Destruye el valor ubicado en ` data`, suponiendo que sea del tipo para el que se construyó esta instancia de ` QMetaType `.
A diferencia de destroy(), esta función solo invoca el destructor del tipo; no invoca el operador delete.
Véase también QMetaType::construct().
[since 6.0] bool QMetaType::equals(const void *lhs, const void *rhs) const
Compara si los objetos de lhs y rhs son iguales.
Ambos objetos deben ser del tipo descrito por este metatipo. Solo se pueden comparar los dos objetos si un operador «menor que» o de igualdad para el tipo era visible en la declaración del metatipo. De lo contrario, el metatipo nunca considera que los valores sean iguales. Cuando un operador de igualdad era visible en la declaración del metatipo, este es determinante; de lo contrario, si es visible el operador «menor que», cuando ninguno de los valores es menor que el otro, ambos se consideran iguales. Si los valores no están ordenados (véase compare() para más detalles), no se consideran iguales.
Devuelve «true» si los dos objetos son iguales; en caso contrario, devuelve «false».
Esta función se introdujo en Qt 6.0.
Véase también isEqualityComparable() y compare().
[constexpr] QMetaType::TypeFlags QMetaType::flags() const
Devuelve los indicadores del tipo para el que se creó esta instancia de QMetaType. Para examinar características específicas del tipo, es preferible utilizar una de las funciones «is-» en lugar de los indicadores directamente.
Véase también QMetaType::TypeFlags, isDefaultConstructible(), isCopyConstructible(), isMoveConstructible(), isDestructible(), isEqualityComparable() y isOrdered().
[static] QMetaType QMetaType::fromName(QByteArrayView typeName)
Devuelve un objeto ` QMetaType ` que coincide con ` typeName`. El objeto devuelto no es válido si `typeName` no es conocido por QMetaType
[static constexpr] template <typename T> QMetaType QMetaType::fromType()
Devuelve el objeto « QMetaType » correspondiente al tipo indicado en el parámetro de plantilla.
[static] bool QMetaType::hasRegisteredConverterFunction(QMetaType fromType, QMetaType toType)
Devuelve ` true` si el sistema de metatipos tiene registrada una conversión del identificador de metatipo ` fromType ` a toType
[static] template <typename From, typename To> bool QMetaType::hasRegisteredConverterFunction()
Devuelve ` true` si el sistema de metatipos tiene registrada una conversión del tipo `From` al tipo `To`.
Esta es una función sobrecargada.
[since 6.1] bool QMetaType::hasRegisteredDataStreamOperators() const
Devuelve ` true` si el sistema de metatipos tiene registrados operadores de flujo de datos para este metatipo.
Esta función se introdujo en Qt 6.1.
[since 6.0] bool QMetaType::hasRegisteredDebugStreamOperator() const
Devuelve ` true` si el sistema de metatipos tiene registrado un operador de flujo de depuración para este metatipo.
Esta función se introdujo en Qt 6.0.
[static] bool QMetaType::hasRegisteredMutableViewFunction(QMetaType fromType, QMetaType toType)
Devuelve ` true` si el sistema de metatipos tiene registrada una vista mutable con el identificador de metatipo ` fromType ` del metatipo con identificador ` toType`.
[static, since 6.0] template <typename From, typename To> bool QMetaType::hasRegisteredMutableViewFunction()
Devuelve ` true` si el sistema de metatipos tiene registrada una vista mutable del tipo `From` del tipo `To`.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
int QMetaType::id() const
Devuelve el tipo de identificador que contiene esta instancia de ` QMetaType `.
[noexcept, since 6.5] bool QMetaType::isCopyConstructible() const
Devuelve «true» si este tipo puede construirse mediante copia. Si es así, entonces se pueden utilizar « construct()» y « create()» con un parámetro « copy » que no sea nulo.
Esta función se introdujo en Qt 6.5.
Véanse también flags(), isDefaultConstructible(), isMoveConstructible() y isDestructible().
[noexcept, since 6.5] bool QMetaType::isDefaultConstructible() const
Devuelve «true» si este tipo puede construirse por defecto. Si es así, entonces se pueden utilizar construct() y create() con un parámetro copy que sea nulo.
Esta función se introdujo en Qt 6.5.
Véanse también flags(), isCopyConstructible(), isMoveConstructible() y isDestructible().
[noexcept, since 6.5] bool QMetaType::isDestructible() const
Devuelve «true» si este tipo puede destruirse. Si es así, se pueden llamar a las funciones ` destroy()` y ` destruct()`.
Esta función se introdujo en Qt 6.5.
Véase también flags(), isDefaultConstructible(), isCopyConstructible() y isMoveConstructible().
bool QMetaType::isEqualityComparable() const
Devuelve « true » si el operador «menor o igual que» para el tipo descrito por este metatipo era visible en la declaración del metatipo; en caso contrario, devuelve « false ».
Véanse también equals() y isOrdered().
[noexcept, since 6.5] bool QMetaType::isMoveConstructible() const
Devuelve «true» si este tipo puede construirse mediante movimiento. Actualmente, « QMetaType » no dispone de una API para hacer uso de este rasgo.
Esta función se introdujo en Qt 6.5.
Véase también flags(), isDefaultConstructible(), isCopyConstructible() y isDestructible().
bool QMetaType::isOrdered() const
Devuelve « true » si el operador «menor que» para el tipo descrito por este metatipo era visible en la declaración del metatipo; en caso contrario, devuelve « false ».
Véase también compare() y isEqualityComparable().
[noexcept] bool QMetaType::isRegistered() const
Devuelve ` true ` si este objeto ` QMetaType ` se ha registrado en el registro global de metatipos de Qt. El registro permite localizar el tipo por su nombre (utilizando ` QMetaType::fromName()`) o por su ID (utilizando el constructor).
Véase también qRegisterMetaType() y isValid().
[static] bool QMetaType::isRegistered(int type)
Devuelve « true » si el tipo de datos con el ID « type » está registrado; en caso contrario, devuelve « false ».
[constexpr noexcept] bool QMetaType::isValid() const
Devuelve « true » si este objeto ` QMetaType ` contiene información válida sobre un tipo; en caso contrario, devuelve «false».
Véase también isRegistered().
bool QMetaType::load(QDataStream &stream, void *data) const
Lee el objeto de este tipo desde la dirección stream y lo almacena en data. Devuelve true si el objeto se ha cargado correctamente; en caso contrario, devuelve false.
Normalmente, no debería ser necesario llamar a esta función directamente. En su lugar, utilice ` operator>>()` de ` QVariant`, que se basa en `load()` para leer tipos personalizados.
Véase también save().
[constexpr] const QMetaObject *QMetaType::metaObject() const
Devuelve un ` QMetaObject ` relativo a este tipo.
Si el tipo es un tipo de puntero a una subclase de ` QObject`, ` flags()` contiene ` QMetaType::PointerToQObject ` y esta función devuelve el ` QMetaObject` correspondiente. Esto se puede utilizar junto con ` QMetaObject::newInstance()` para crear objetos `QObject` de este tipo.
Si el tipo es un ` Q_GADGET`, ` flags()` contiene ` QMetaType::IsGadget`. Si el tipo es un puntero a un ` Q_GADGET`, ` flags()` contiene ` QMetaType::PointerToGadget`. En ambos casos, esta función devuelve su ` QMetaObject`. Esto se puede utilizar para recuperar ` QMetaMethod ` y ` QMetaProperty ` y utilizarlos en un puntero de este tipo, por ejemplo, tal y como lo proporciona ` QVariant::data()`.
Si el tipo es una enumeración, flags() contiene QMetaType::IsEnumeration. En este caso, esta función devuelve el QMetaObject del objeto contenedor si la enumeración se registró como un Q_ENUM; de lo contrario, devuelve un nullptr.
Véase también QMetaType::flags().
[constexpr] const char *QMetaType::name() const
Devuelve el nombre del tipo asociado a este ` QMetaType`, o un puntero nulo si no se ha encontrado ningún tipo que coincida. El puntero devuelto no debe eliminarse.
Véase también typeName().
[static] template <typename From, typename To> bool QMetaType::registerConverter()
Registra la posibilidad de una conversión implícita del tipo «From» al tipo «To» en el sistema de metatipos. Devuelve « true » si el registro se ha realizado correctamente; en caso contrario, devuelve «false».
class Counter {
int number = 0;
public:
int value() const { return number; }
operator int() const { return value(); }
void increment() {++number;}
};
QMetaType::registerConverter<Counter, int>();[static] template <typename From, typename To> bool QMetaType::registerConverter(To (From::*function)() const)
Registra un método function como To From::function() const en el sistema de metatipos, a modo de convertidor del tipo From al tipo To. Devuelve true si el registro se ha realizado correctamente; en caso contrario, devuelve false.
struct Coordinates {
int x;
int y;
int z;
QString toString() const { return u"[x: %1; y: %2, z: %3]"_s.arg(QString::number(x),
QString::number(y),
QString::number(z)); }
};
QMetaType::registerConverter<Coordinates, QString>(&Coordinates::toString);Esta es una función sobrecargada.
[static] template <typename From, typename To> bool QMetaType::registerConverter(To (From::*function)(bool *) const)
Registra un método function como To From::function(bool *ok) const como convertidor del tipo From al tipo To en el sistema de metatipos. Devuelve true si el registro se ha realizado correctamente; en caso contrario, devuelve false.
La función puede utilizar el puntero ok para indicar si la conversión se ha realizado con éxito.
struct BigNumber {
long long l;
int toInt(bool *ok = nullptr) const {
const bool canConvertSafely = l < std::numeric_limits<int>::max();
if (ok)
*ok = canConvertSafely;
return l;
}
};
QMetaType::registerConverter<BigNumber, int>(&BigNumber::toInt);Se trata de una función sobrecargada.
[static] template <
typename From,
typename To,
typename UnaryFunction
>
bool QMetaType::registerConverter(UnaryFunction function)
Registra un objeto de función unaria function como convertidor del tipo «From» al tipo «To» en el sistema de metatipos. Devuelve true si el registro se ha realizado correctamente; en caso contrario, devuelve «false».
function Debe tomar una instancia del tipo From y devolver una instancia de To. Puede ser un puntero a función, una lambda o un objeto functor. Desde Qt 6.5, la función function también puede devolver una instancia de std::optional<To> para poder indicar conversiones fallidas.
QMetaType::registerConverter<CustomStringType, QString>([](const CustomStringType &str) {
return QString::fromUtf8(str.data());
});
QMetaType::registerConverter<QJsonValue, CustomPointType>(
[](const QJsonValue &value) -> std::optional<CustomPointType> {
const auto object = value.toObject();
if (!object.contains("x") || !object.contains("y"))
return std::nullopt; // The conversion fails if the required properties are missing
return CustomPointType{object["x"].toDouble(), object["y"].toDouble()};
});Se trata de una función sobrecargada.
[static, since 6.0] template <typename From, typename To> bool QMetaType::registerMutableView(To (From::*function)())
Registra un método function como To From::function(), a modo de vista mutable del tipo To sobre el tipo From en el sistema de metatipos. Devuelve true si el registro se ha realizado correctamente; en caso contrario, devuelve false.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
[static, since 6.0] template <
typename From,
typename To,
typename UnaryFunction
>
bool QMetaType::registerMutableView(UnaryFunction function)
Registra un objeto de función unaria ` function ` como vista mutable de tipo `To` sobre el tipo `From` en el sistema de metatipos. Devuelve ` true ` si el registro se ha realizado correctamente; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
[since 6.5] void QMetaType::registerType() const
Registra este ` QMetaType ` en el registro de tipos para que se pueda localizar por su nombre, mediante ` QMetaType::fromName()`.
Esta función se introdujo en Qt 6.5.
Véase también qRegisterMetaType().
bool QMetaType::save(QDataStream &stream, const void *data) const
Escribe el objeto al que apunta data en el stream indicado. Devuelve true si el objeto se ha guardado correctamente; en caso contrario, devuelve false.
Normalmente, no debería ser necesario llamar a esta función directamente. En su lugar, utilice la función ` operator<<()` de ` QVariant`, que se basa en `save()` para transmitir tipos personalizados.
Véase también load().
[constexpr] qsizetype QMetaType::sizeOf() const
Devuelve el tamaño del tipo en bytes (es decir, `sizeof(T)`, donde `T` es el tipo real para el que se creó esta instancia de ` QMetaType `).
Esta función se suele utilizar junto con ` construct()` para llevar a cabo una gestión de bajo nivel de la memoria utilizada por un tipo.
Véanse también ` QMetaType::construct()` y ` QMetaType::alignOf()`.
[since 6.6] QMetaType QMetaType::underlyingType() const
Si este metatipo representa una enumeración, este método devuelve un metatipo de una clase numérica con el mismo signo y tamaño que el tipo subyacente de la enumeración. Si representa un tipo « QFlags », devuelve « QMetaType::Int ». En todos los demás casos, se devuelve un « QMetaType » no válido.
Esta función se introdujo en Qt 6.6.
[static, since 6.0] bool QMetaType::view(QMetaType fromType, void *from, QMetaType toType, void *to)
Crea una vista mutable del objeto situado en from de tipo fromType en el espacio preasignado en to de tipo toType. Devuelve true si la conversión se ha realizado correctamente; en caso contrario, devuelve false.
Esta función se introdujo en Qt 6.0.
Elementos no miembros relacionados
[since 6.4] size_t qHash(QMetaType 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.4.
[constexpr] template <typename T> int qMetaTypeId()
Devuelve el identificador del metatipo de tipo « T » en tiempo de compilación. Si el tipo no se ha declarado mediante « Q_DECLARE_METATYPE()», la compilación fallará.
Uso habitual:
int id = qMetaTypeId<QString>(); // id is now QMetaType::QString
id = qMetaTypeId<MyStruct>(); // compile error if MyStruct not declaredQMetaType::type() devuelve el mismo identificador que qMetaTypeId(), pero realiza una búsqueda en tiempo de ejecución basándose en el nombre del tipo. QMetaType::type() es un poco más lento, pero la compilación se realiza correctamente aunque el tipo no esté registrado.
Véase también Q_DECLARE_METATYPE() y QMetaType::type().
[constexpr] template <typename T> int qRegisterMetaType()
Llama a esta función para registrar el tipo « T ». Devuelve el identificador del metatipo.
Ejemplo:
int id = qRegisterMetaType<MyStruct>();Esta función requiere que T sea un tipo completamente definido en el momento en que se llama a la función. En el caso de los tipos de puntero, también requiere que el tipo al que apunta esté completamente definido. Utiliza Q_DECLARE_OPAQUE_POINTER() para poder registrar punteros a tipos declarados por adelantado.
Para utilizar el tipo T en QMetaType, QVariant o con la API QObject::property(), no es necesario registrarlo.
Para utilizar el tipo T en conexiones de señales y ranuras en cola, se debe llamar a qRegisterMetaType<T>() antes de establecer la primera conexión. Esto se suele hacer en el constructor de la clase que utiliza T, o en la función main().
Una vez registrado un tipo, se puede localizar por su nombre utilizando QMetaType::fromName().
Véase también Q_DECLARE_METATYPE().
[since 6.5] int qRegisterMetaType(QMetaType meta)
Registra el metatipo meta y devuelve su identificador de tipo.
Para utilizar un tipo con el metatipo « meta » en conexiones de señales y ranuras en cola, se debe llamar a « qRegisterMetaType(meta) » antes de establecer la primera conexión. Esto se suele hacer en el constructor de la clase que utiliza el metatipo, o en la función « main() ».
Una vez registrado un tipo, se puede localizar por su nombre utilizando QMetaType::fromName().
Esta función se introdujo en Qt 6.5.
[noexcept] bool operator!=(const QMetaType &lhs, const QMetaType &rhs)
Devuelve « true » si « QMetaType » lhs representa un tipo diferente al de « QMetaType » rhs; en caso contrario, devuelve « false ».
[since 6.5] QDebug operator<<(QDebug d, QMetaType m)
Escribe el objeto ` QMetaType ` m en el flujo ` d` y devuelve dicho flujo.
Esta función se introdujo en Qt 6.5.
[noexcept] bool operator==(const QMetaType &lhs, const QMetaType &rhs)
Devuelve « true » si « QMetaType » lhs representa el mismo tipo que « QMetaType » rhs; en caso contrario, devuelve « false ».
Documentación de la macro
Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE(Container)
Esta macro hace que el contenedor Container sea reconocido por QMetaType como un contenedor asociativo. Esto permite introducir una instancia de Container<T, U> en un QVariant, siempre que T y U sean a su vez reconocidos por QMetaType.
Tenga en cuenta que todos los contenedores asociativos de Qt ya cuentan con soporte integrado, por lo que no es necesario utilizar esta macro con ellos. El contenedor std::map también cuenta con soporte integrado.
Este ejemplo muestra un uso típico de Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE():
#include <unordered_map>
Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE(std::unordered_map)
void someFunction()
{
std::unordered_map<int, bool> container;
QVariant var = QVariant::fromValue(container);
// ...
}Q_DECLARE_METATYPE(Type)
Esta macro hace que el tipo Type sea reconocido por QMetaType, siempre y cuando proporcione un constructor por defecto público, un constructor de copia público y un destructor público. Es necesaria para utilizar el tipo Type como tipo personalizado en QVariant.
Esta macro requiere que Type sea un tipo completamente definido en el punto en el que se utiliza. En el caso de los tipos de puntero, también requiere que el tipo al que apunta esté completamente definido. Úsese junto con Q_DECLARE_OPAQUE_POINTER() para registrar punteros a tipos declarados por adelantado.
Lo ideal es colocar esta macro debajo de la declaración de la clase o estructura. Si eso no es posible, se puede incluir en un archivo de cabecera privado que deberá incluirse cada vez que se utilice ese tipo en un ` QVariant`.
Al añadir un `Q_DECLARE_METATYPE()`, el tipo queda reconocido por todas las funciones basadas en plantillas, incluida ` QVariant`. Ten en cuenta que, si pretendes utilizar el tipo en conexiones de señales y ranuras en cola o en el sistema de propiedades de ` QObject`, también debes llamar a ` qRegisterMetaType()`, ya que los nombres se resuelven en tiempo de ejecución.
Este ejemplo muestra un caso de uso típico de Q_DECLARE_METATYPE():
struct MyStruct
{
int i;
//...
};
Q_DECLARE_METATYPE(MyStruct)Si MyStruct se encuentra en un espacio de nombres, la macro Q_DECLARE_METATYPE() debe estar fuera de dicho espacio de nombres:
namespace MyNamespace
{
struct MyStruct
{
//...
};
}
Q_DECLARE_METATYPE(MyNamespace::MyStruct)Dado que QMetaType ya conoce MyStruct, puede utilizarse en QVariant:
MyStruct s;
QVariant var;
var.setValue(s); // copy s into the variant
//...
// retrieve the value
MyStruct s2 = var.value<MyStruct>();Algunos tipos se registran automáticamente y no necesitan esta macro:
- Los punteros a clases derivadas de QObject
- QList<T>, QQueue<T>, QStack<T> o QSet<T>, donde T es un metatipo registrado
- QHash<T1, T2>, QMap<T1, T2> o std::pair<T1, T2>, donde T1 y T2 son metatipos registrados
- QPointer<T>, QSharedPointer<T>, QWeakPointer<T>, donde T es una clase que deriva de QObject
- enumeraciones registradas con Q_ENUM o Q_FLAG
- clases que tengan una macro Q_GADGET
Nota: Este método también registra los operadores de flujo y de depuración para el tipo si están visibles en el momento del registro. Dado que esto se realiza automáticamente en algunos casos, se recomienda encarecidamente declarar los operadores de flujo para un tipo directamente después del propio tipo. Debido a las reglas de búsqueda dependientes de los argumentos de C++, también se recomienda encarecidamente declarar los operadores en el mismo espacio de nombres que el propio tipo.
Los operadores de flujo deben tener las siguientes firmas:
QDataStream &operator<<(QDataStream &out, const MyClass &myObj);
QDataStream &operator>>(QDataStream &in, MyClass &myObj);Véase también ` qRegisterMetaType()`.
Q_DECLARE_OPAQUE_POINTER(PointerType)
Esta macro permite registrar punteros a tipos declarados de forma anticipada (PointerType) en QMetaType utilizando Q_DECLARE_METATYPE() o qRegisterMetaType().
No utilices esta macro para evitar mensajes de advertencia o errores de moc sobre tipos de propiedad incompletos cuando el tipo al que apunta el puntero se utilice como un tipo completo en otros contextos del programa. Utiliza en su lugar Q_MOC_INCLUDE cuando la definición completa del tipo esté disponible, pero prefieras una declaración anticipada en el encabezado para reducir los tiempos de compilación.
Advertencia: No utilices Q_DECLARE_OPAQUE_POINTER con punteros a una clase ` Q_OBJECT ` o a una clase de gadget, ya que ello conlleva el riesgo de introducir información inconsistente en el sistema de metatipos.
Véase también Q_DECLARE_METATYPE() y qRegisterMetaType().
Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(Container)
Esta macro hace que el contenedor Container sea reconocido por QMetaType como un contenedor secuencial. Esto permite introducir una instancia de Container<T> en un QVariant, siempre que T sea reconocido por QMetaType.
Ten en cuenta que todos los contenedores secuenciales de Qt ya cuentan con soporte integrado, por lo que no es necesario utilizar esta macro con ellos. Los contenedores std::vector y std::list también cuentan con soporte integrado.
Este ejemplo muestra un uso típico de Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE():
#include <deque>
Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(std::deque)
void someFunc()
{
std::deque<QFile*> container;
QVariant var = QVariant::fromValue(container);
// ...
}Q_DECLARE_SMART_POINTER_METATYPE(SmartPointer)
Esta macro hace que el puntero inteligente SmartPointer sea reconocido por QMetaType como un puntero inteligente. Esto permite introducir una instancia de SmartPointer<T> en un QVariant, siempre que T sea un tipo que herede de QObject.
Ten en cuenta que QWeakPointer, QSharedPointer y QPointer ya cuentan con soporte integrado, por lo que no es necesario utilizar esta macro con ellos.
Este ejemplo muestra un uso típico de `Q_DECLARE_SMART_POINTER_METATYPE()`:
#include <memory>
Q_DECLARE_SMART_POINTER_METATYPE(std::shared_ptr)
void someMethod()
{
auto smart_ptr = std::make_shared<QFile>();
QVariant var = QVariant::fromValue(smart_ptr);
// ...
if (var.canConvert<QObject*>()) {
QObject*sp = var.value<QObject*>();
qDebug() << sp->metaObject()->className(); // Prints 'QFile'.
}
}© 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.