QMetaType

 #include <QMetaType>

 int id = QMetaType::type("MyClass");
 if (id != 0) {
     void *myClassPtr = QMetaType::construct(id);
     ...
     QMetaType::destroy(id, myClassPtr);
     myClassPtr = 0;
 }

Related Non-Members

int qMetaTypeId ()

Returns the meta type id of type T at compile time. If the type was not declared with Q_DECLARE_METATYPE(), compilation will fail.

Typical usage:

 int id = qMetaTypeId<QString>();    // id is now QMetaType::QString
 id = qMetaTypeId<MyStruct>();       // compile error if MyStruct not declared

QMetaType::type() returns the same ID as qMetaTypeId(), but does a lookup at runtime based on the name of the type. QMetaType::type() is a bit slower, but compilation succeeds if a type is not registered.

Note: This function is thread-safe.

This function was introduced in Qt 4.1.

See also Q_DECLARE_METATYPE() and QMetaType::type().

int qRegisterMetaType ( const char * typeName )

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.

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");

Note: This function is thread-safe.

See also qRegisterMetaTypeStreamOperators(), QMetaType::isRegistered(), and Q_DECLARE_METATYPE().

int qRegisterMetaType ()

Call this function to register the type T. T must be declared with Q_DECLARE_METATYPE(). Returns the meta type Id.

Example:

 int id = qRegisterMetaType<MyStruct>();

To use the type T in QVariant, using Q_DECLARE_METATYPE() is sufficient. To use the type T in queued signal and slot connections, qRegisterMetaType<T>() must be called before the first connection is established.

Also, to use type T with the QObject::property() API, qRegisterMetaType<T>() must be called before it is used, typically in the constructor of the class that uses T, or in the main() function.

Note: This function is thread-safe.

This function was introduced in Qt 4.2.

See also Q_DECLARE_METATYPE().

void qRegisterMetaTypeStreamOperators ( const char * typeName )

Registers the stream operators for the type T called typeName.

Afterward, the type can be streamed using QMetaType::load() and QMetaType::save(). These functions are used when streaming a QVariant.

 qRegisterMetaTypeStreamOperators<MyClass>("MyClass");

The stream operators should have the following signatures:

 QDataStream &operator<<(QDataStream &out, const MyClass &myObj);
 QDataStream &operator>>(QDataStream &in, MyClass &myObj);

Note: This function is thread-safe.

See also qRegisterMetaType(), QMetaType::isRegistered(), and Q_DECLARE_METATYPE().

 struct MyStruct
 {
     int i;
     ...
 };

 Q_DECLARE_METATYPE(MyStruct)

 namespace MyNamespace
 {
     ...
 }

 Q_DECLARE_METATYPE(MyNamespace::MyStruct)

 MyStruct s;
 QVariant var;
 var.setValue(s); // copy s into the variant

 ...

 // retrieve the value
 MyStruct s2 = var.value<MyStruct>();