The Meta-Object System¶
An overview of Qt’s meta-object system and introspection capabilities.
Qt’s meta-object system provides the signals and slots mechanism for inter-object communication, run-time type information, and the dynamic property system.
The meta-object system is based on three things:
The
QObject
class provides a base class for objects that can take advantage of the meta-object system.The
Q_OBJECT
macro inside the private section of the class declaration is used to enable meta-object features, such as dynamic properties, signals, and slots.The Meta-Object Compiler (
moc
) supplies eachQObject
subclass with the necessary code to implement meta-object features.The
moc
tool reads a C++ source file. If it finds one or more class declarations that contain theQ_OBJECT
macro, it produces another C++ source file which contains the meta-object code for each of those classes. This generated source file is either#include
‘d into the class’s source file or, more usually, compiled and linked with the class’s implementation.In addition to providing the signals and slots mechanism for communication between objects (the main reason for introducing the system), the meta-object code provides the following additional features:
metaObject()
returns the associatedmeta-object
for the class.
className()
returns the class name as a string at run-time, without requiring native run-time type information (RTTI) support through the C++ compiler.
inherits()
function returns whether an object is an instance of a class that inherits a specified class within theQObject
inheritance tree.
tr()
andtrUtf8()
translate strings for internationalization.
setProperty()
andproperty()
dynamically set and get properties by name.
newInstance()
constructs a new instance of the class.It is also possible to perform dynamic casts using
qobject_cast()
onQObject
classes. Theqobject_cast()
function behaves similarly to the standard C++dynamic_cast()
, with the advantages that it doesn’t require RTTI support and it works across dynamic library boundaries. It attempts to cast its argument to the pointer type specified in angle-brackets, returning a non-zero pointer if the object is of the correct type (determined at run-time), orNone
if the object’s type is incompatible.For example, let’s assume
MyWidget
inherits fromQWidget
and is declared with theQ_OBJECT
macro:QObject *obj = new MyWidget;The
obj
variable, of typeQObject *
, actually refers to aMyWidget
object, so we can cast it appropriately:QWidget *widget = qobject_cast<QWidget *>(obj);The cast from
QObject
toQWidget
is successful, because the object is actually aMyWidget
, which is a subclass ofQWidget
. Since we know thatobj
is aMyWidget
, we can also cast it toMyWidget *
:MyWidget *myWidget = qobject_cast<MyWidget *>(obj);The cast to
MyWidget
is successful becauseqobject_cast()
makes no distinction between built-in Qt types and custom types.QLabel *label = qobject_cast<QLabel *>(obj); // label is 0The cast to
QLabel
, on the other hand, fails. The pointer is then set to 0. This makes it possible to handle objects of different types differently at run-time, based on the type:if (QLabel *label = qobject_cast<QLabel *>(obj)) { label->setText(tr("Ping")); } else if (QPushButton *button = qobject_cast<QPushButton *>(obj)) { button->setText(tr("Pong!")); }While it is possible to use
QObject
as a base class without theQ_OBJECT
macro and without meta-object code, neither signals and slots nor the other features described here will be available if theQ_OBJECT
macro is not used. From the meta-object system’s point of view, aQObject
subclass without meta code is equivalent to its closest ancestor with meta-object code. This means for example, thatclassName()
will not return the actual name of your class, but the class name of this ancestor.Therefore, we strongly recommend that all subclasses of
QObject
use theQ_OBJECT
macro regardless of whether or not they actually use signals, slots, and properties.See also
QMetaObject
Qt’s Property System Signals and Slots
© 2022 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.