- Qt 6.10
- Qt Core
- C++ Classes
- QMetaType
- Qt 6.10.2 Reference Documentation

# Obsolete Members for QMetaType

The following members of class QMetaType are deprecated. They are provided to keep old source code working. We strongly advise against using them in new code.

## Static Public Members

`(deprecated)` bool | compare(const void *lhs, const void *rhs, int typeId, int *result)
`(deprecated)` void * | construct(int type, void *where, const void *copy)
`(deprecated)` bool | convert(const void *from, int fromTypeId, void *to, int toTypeId)
`(deprecated)` void * | create(int type, const void *copy = nullptr)
`(deprecated)` bool | debugStream(QDebug &dbg, const void *rhs, int typeId)
`(deprecated)` void | destroy(int type, void *data)
`(deprecated)` void | destruct(int type, void *where)
`(deprecated)` bool | hasRegisteredDebugStreamOperator()
`(deprecated)` bool | hasRegisteredDebugStreamOperator(int typeId)
`(deprecated)` bool | load(QDataStream &stream, int type, void *data)
`(deprecated)` const QMetaObject * | metaObjectForType(int type)
`(deprecated)` bool | save(QDataStream &stream, int type, const void *data)
`(deprecated)` int | sizeOf(int type)
`(deprecated)` int | type(const char *typeName)
`(deprecated)` int | type(const QByteArray &typeName)
`(deprecated)` QMetaType::TypeFlags | typeFlags(int type)
`(deprecated)` const char * | typeName(int typeId)

## Related Non-Members

`(deprecated)` int | qRegisterMetaType(const char *typeName)

## Member Function Documentation

### `[static, deprecated]` bool QMetaType::compare(const void *lhs, const void *rhs, int typeId, int *result)

This function is deprecated. We strongly advise against using it in new code.

Use the non-static compare method instead

Compares the objects at lhs and rhs. Both objects need to be of type typeId. result is set to less than, equal to or greater than zero, if lhs is less than, equal to or greater than rhs. Returns `true`, if the comparison succeeded, otherwise `false`.

### `[static, deprecated]` void *QMetaType::construct(int type, void *where, const void *copy)

This function is deprecated. We strongly advise against using it in new code.

Constructs a value of the given type in the existing memory addressed by where, that is a copy of copy, and returns where. If copy is zero, the value is default constructed.

This is a low-level function for explicitly managing the memory used to store the type. Consider calling create() if you don't need this level of control (that is, use "new" rather than "placement new").

You must ensure that where points to a location that can store a value of type type, and that where is suitably aligned. The type's size can be queried by calling sizeOf().

The rule of thumb for alignment is that a type is aligned to its natural boundary, which is the smallest power of 2 that is bigger than the type, unless that alignment is larger than the maximum useful alignment for the platform. For practical purposes, alignment larger than 2 * sizeof(void*) is only necessary for special hardware instructions (e.g., aligned SSE loads and stores on x86).

See also destruct() and sizeOf().

### `[static, deprecated]` bool QMetaType::convert(const void *from, int fromTypeId, void *to, int toTypeId)

This function is deprecated. We strongly advise against using it in new code.

Converts the object at from from fromTypeId to the preallocated space at to typed toTypeId. Returns `true`, if the conversion succeeded, otherwise false.

Both from and to have to be valid pointers.

### `[static, deprecated]` void *QMetaType::create(int type, const void *copy = nullptr)

This function is deprecated. We strongly advise against using it in new code.

Returns a copy of copy, assuming it is of type type. If copy is zero, creates a default constructed instance.

See also destroy(), isRegistered(), and Type.

### `[static, deprecated]` bool QMetaType::debugStream(QDebug &dbg, const void *rhs, int typeId)

This function is deprecated. We strongly advise against using it in new code.

This is an overloaded function.

### `[static, deprecated]` void QMetaType::destroy(int type, void *data)

This function is deprecated. We strongly advise against using it in new code.

Destroys the data, assuming it is of the type given.

See also create(), isRegistered(), and Type.

### `[static, deprecated]` void QMetaType::destruct(int type, void *where)

This function is deprecated. We strongly advise against using it in new code.

Destructs the value of the given type, located at where.

Unlike destroy(), this function only invokes the type's destructor, it doesn't invoke the delete operator.

See also construct().

### `[static, deprecated]` template <typename T> bool QMetaType::hasRegisteredDebugStreamOperator()

This function is deprecated. We strongly advise against using it in new code.

Returns `true`, if the meta type system has a registered debug stream operator for type T.

### `[static, deprecated]` bool QMetaType::hasRegisteredDebugStreamOperator(int typeId)

This function is deprecated. We strongly advise against using it in new code.

Use QMetaType::hasRegisteredDebugStreamOperator() instead.

Returns `true`, if the meta type system has a registered debug stream operator for type id typeId.

### `[static, deprecated]` bool QMetaType::load(QDataStream &stream, int type, void *data)

This function is deprecated. We strongly advise against using it in new code.

This is an overloaded function.

### `[static, deprecated]` const QMetaObject *QMetaType::metaObjectForType(int type)

This function is deprecated. We strongly advise against using it in new code.

returns QMetaType::metaObject for type

See also metaObject().

### `[static, deprecated]` bool QMetaType::save(QDataStream &stream, int type, const void *data)

This function is deprecated. We strongly advise against using it in new code.

This is an overloaded function.

### `[static, deprecated]` int QMetaType::sizeOf(int type)

This function is deprecated. We strongly advise against using it in new code.

Returns the size of the given type in bytes (i.e. sizeof(T), where T is the actual type identified by the type argument).

This function is typically used together with construct() to perform low-level management of the memory used by a type.

See also construct() and QMetaType::alignOf().

### `[static, deprecated]` int QMetaType::type(const char *typeName)

This function is deprecated. We strongly advise against using it in new code.

Returns a handle to the type called typeName, or QMetaType::UnknownType if there is no such type.

See also isRegistered(), typeName(), and Type.

### `[static, deprecated]` int QMetaType::type(const QByteArray &typeName)

This function is deprecated. We strongly advise against using it in new code.

Returns a handle to the type called typeName, or 0 if there is no such type.

This is an overloaded function.

See also isRegistered() and typeName().

### `[static, deprecated]` QMetaType::TypeFlags QMetaType::typeFlags(int type)

This function is deprecated. We strongly advise against using it in new code.

Returns flags of the given type.

See also QMetaType::TypeFlags.

### `[static, deprecated]` const char *QMetaType::typeName(int typeId)

This function is deprecated. We strongly advise against using it in new code.

Returns the type name associated with the given typeId, or a null pointer if no matching type was found. The returned pointer must not be deleted.

See also type(), isRegistered(), Type, and name().

## Related Non-Members

### `[deprecated]` template <typename T> int qRegisterMetaType(const char *typeName)

This function is deprecated. We strongly advise against using it in new code.

Registers the type name typeName for the type `T`. Returns the internal ID used by QMetaType. Any class or struct that has a public default constructor, a public copy constructor and a public destructor can be registered.

This function requires that `T` is a fully defined type at the point where the function is called. For pointer types, it also requires that the pointed to type is fully defined. Use Q_DECLARE_OPAQUE_POINTER() to be able to register pointers to forward declared types.

After a type has been registered, you can create and destroy objects of that type dynamically at run-time.

This example registers the class `MyClass`:

     qRegisterMetaType<MyClass>("MyClass");

This function is useful to register typedefs so they can be used by QMetaProperty, or in QueuedConnections

     typedef QString CustomString;
     qRegisterMetaType<CustomString>("CustomString");

Warning: This function is useful only for registering an alias (typedef) for every other use case Q_DECLARE_METATYPE and qMetaTypeId() should be used instead.

See also isRegistered() and Q_DECLARE_METATYPE().