En esta página

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íaTipos comparables
igualdadQMetaType

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

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:

ConstanteValorDescripción
QMetaType::Void43void
QMetaType::Bool1bool
QMetaType::Int2int
QMetaType::UInt3unsigned int
QMetaType::Double6double
QMetaType::QChar7QChar
QMetaType::QString10QString
QMetaType::QByteArray12QByteArray
QMetaType::Nullptr51std::nullptr_t
QMetaType::VoidStar31void *
QMetaType::Long32long
QMetaType::LongLong4LongLong
QMetaType::Short33short
QMetaType::Char34char
QMetaType::Char1656char16_t
QMetaType::Char3257char32_t
QMetaType::ULong35unsigned long
QMetaType::ULongLong5ULongLong
QMetaType::UShort36unsigned short
QMetaType::SChar40signed char
QMetaType::UChar37unsigned char
QMetaType::Float38float
QMetaType::Float1663qfloat16
QMetaType::QObjectStar39QObject *
QMetaType::QBitArray13QBitArray
QMetaType::QBitmap0x1009QBitmap
QMetaType::QBrush0x1002QBrush
QMetaType::QByteArrayList49QByteArrayList
QMetaType::QCborArray54QCborArray
QMetaType::QCborMap55QCborMap
QMetaType::QCborSimpleType52QCborSimpleType
QMetaType::QCborValue53QCborValue
QMetaType::QColor0x1003QColor
QMetaType::QColorSpace0x1017QColorSpace (introducido en Qt 5.15)
QMetaType::QCursor0x100aQCursor
QMetaType::QDate14QDate
QMetaType::QDateTime16QDateTime
QMetaType::QEasingCurve29QEasingCurve
QMetaType::QFont0x1000QFont
QMetaType::QIcon0x1005QIcon
QMetaType::QImage0x1006QImage
QMetaType::QJsonArray47QJsonArray
QMetaType::QJsonDocument48QJsonDocument
QMetaType::QJsonObject46QJsonObject
QMetaType::QJsonValue45QJsonValue
QMetaType::QKeySequence0x100bQKeySequence
QMetaType::QLine23QLine
QMetaType::QLineF24QLineF
QMetaType::QLocale18QLocale
QMetaType::QMatrix4x40x1011QMatrix4x4
QMetaType::QModelIndex42QModelIndex
QMetaType::QPalette0x1004QPaleta
QMetaType::QPen0x100cQPen
QMetaType::QPersistentModelIndex50QPersistentModelIndex (introducido en Qt 5.5)
QMetaType::QPixmap0x1001QPixmap
QMetaType::QPoint25QPoint
QMetaType::QPointF26QPointF
QMetaType::QPolygon0x1007QPolygon
QMetaType::QPolygonF0x1016QPolygonF
QMetaType::QQuaternion0x1015QCuaternión
QMetaType::QRect19QRect
QMetaType::QRectF20QRectF
QMetaType::QRegion0x1008QRegion
QMetaType::QRegularExpression44QExpresiónRegular
QMetaType::QSize21QSize
QMetaType::QSizeF22QSizeF
QMetaType::QSizePolicy0x2000QSizePolicy
QMetaType::QStringList11QListaDeCadenas
QMetaType::QTextFormat0x100eQTextFormat
QMetaType::QTextLength0x100dQTextLength
QMetaType::QTime15QTime
QMetaType::QTransform0x1010QTransform
QMetaType::QUrl17QUrl
QMetaType::QUuid30QUuid
QMetaType::QVariant41QVariant
QMetaType::QVariantHash28QVariantHash
QMetaType::QVariantList9QVariantList
QMetaType::QVariantMap8QVariantMap
QMetaType::QVariantPair58QVariantPair
QMetaType::QVector2D0x1012QVector2D
QMetaType::QVector3D0x1013QVector3D
QMetaType::QVector4D0x1014QVector4D
QMetaType::User65536Valor base para tipos de usuario
QMetaType::UnknownType0Este 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.

ConstanteValorDescripción
QMetaType::NeedsConstruction0x1Este 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)0x4000Este 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)0x8000Este tipo tiene un constructor de traslado no trivial. Si no se activa el indicador, las instancias se pueden trasladar con `memcpy`.
QMetaType::NeedsDestruction0x2Este tipo tiene un destructor no trivial. Si no se activa el indicador, no es necesario llamar al destructor antes de descartar los objetos.
QMetaType::RelocatableType0x4Una instancia de un tipo que tenga este atributo puede trasladarse de forma segura a una ubicación de memoria diferente utilizando memcpy.
QMetaType::IsEnumeration0x10Este tipo es una enumeración.
QMetaType::IsUnsignedEnumeration0x100Si el tipo es una enumeración, su tipo subyacente es de tipo sin signo.
QMetaType::PointerToQObject0x8Este tipo es un puntero a una clase derivada de ` QObject`.
QMetaType::IsPointer0x800Este tipo es un puntero a otro tipo.
QMetaType::IsConst0x2000Indica 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:

TipoConversión automática a
QMetaType::BoolQMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong
QMetaType::QByteArrayQMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong, QMetaType::QUuid
QMetaType::QCharQMetaType::Bool, QMetaType::Int, QMetaType::UInt, QMetaType::LongLong, QMetaType::ULongLong
QMetaType::QColorQMetaType::QString
QMetaType::QDateQMetaType::QDateTime, QMetaType::QString
QMetaType::QDateTimeQMetaType::QDate, QMetaType::QString, QMetaType::QTime
QMetaType::DoubleQMetaType::Bool, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong
QMetaType::QFontQMetaType::QString
QMetaType::IntQMetaType::Bool, QMetaType::QChar, QMetaType::Double, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong
QMetaType::QKeySequenceQMetaType::Int, QMetaType::QString
QMetaType::QVariantListQMetaType::QStringList (si los elementos de la lista se pueden convertir a QStrings)
QMetaType::LongLongQMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong
QMetaType::QPointQMetaType::QPointF
QMetaType::QRectQMetaType::QRectF
QMetaType::QStringQMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::QColor, QMetaType::QDate, QMetaType::QDateTime, QMetaType::Double, QMetaType::QFont, QMetaType::Int, QMetaType::QKeySequence, QMetaType::LongLong, QMetaType::QStringList, QMetaType::QTime, QMetaType::UInt, QMetaType::ULongLong, QMetaType::QUuid
QMetaType::QStringListQMetaType::QVariantList, QMetaType::QString (si la lista contiene exactamente un elemento)
QMetaType::QTimeQMetaType::QString
QMetaType::UIntQMetaType::Bool, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::ULongLong
QMetaType::ULongLongQMetaType::Bool, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt
QMetaType::QUuidQMetaType::QByteArray, QMetaType::QString

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

Véase también type() y Type.

[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 declared

QMetaType::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:

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.