Functions of Qmake and MOC (★FIRECAT recommended ★)

Original works, allow reprint, please be sure to use hyperlinks in the form of the original source of the article, author information and this statement. Otherwise, the legal liability will be investigated. http://devbean.blog.51cto.com/448512/355100

As we said earlier, Qt is not a "standard" C + + language, but rather "extended" to a certain extent. Here we can see from the new addition of QT Keywords: signals, slots or emit. So some people would think that Qt's program is slow to compile, mainly because in QT the source code to the standard C + + compiler, such as GCC, prior to the need to remove these extended syntax. The MOC is the way to do this.

The MOC full name is Meta-object Compiler, which is the Meta object compiler. QT programs use the MOC to analyze C + + source files before they are compiled by the standard compiler. If it finds that the macro Q_object is included in a header file, another C + + source file is generated. This source file contains the implementation code for the Q_object macro. This new file name will be preceded by the original filename plus the moc_ composition. This new file will also go into the compilation system and eventually be linked to the binary code. So we can see that this new file is not "replacing" the old file, but is involved in compiling it with the original file. Also, we can see that the MOC is executed before the preprocessor. Because the Q_object macro does not exist after the preprocessor executes.

Since each source file needs to be processed by the MOC, when did we call it? In fact, if you use Qmake, this step call will be shown in the generated makefile. Essentially, Qmake is just a makefile generator, so the final execution is done by make.

To see the files generated by the MOC, we use a very simple CPP to test:

Test.cpp

1. Class Test: Public qobject
2. {
3. Q_object
4. Public
5. explicit Test (Qobject *parent = 0);
6. Signals:
7. Public Slots:
8. };

This is a blank class and nothing is implemented. After compiling, we will find the Moc_test.cpp in the output folder:

Moc_test.cpp

2. /****************************************************************************
4. * * Meta object code from reading C + + file ' test.h '
6. **
8. * * Created:thu Jul 22 13:06:45 2010
10. * * by:the qt Meta Object Compiler version (QT 4.6.3)
12. **
14. * * warning! All changes made in this file would be lost!
16. *****************************************************************************/
20. #include ". /test.h "
22. #if!defined (q_moc_output_revision)
24. #error "The header file ' test.h ' doesn ' t include <qobject>."
26. #elif q_moc_output_revision! = 62
28. #error "This file is generated using the MOC from 4.6.3. It "
30. #error "Cannot is used with the include files from this version of Qt."
32. #error "(the MOC has changed too much.)
34. #endif
38. Qt_begin_moc_namespace
40. Static const UINT Qt_meta_data_test[] = {
44. //content:
46. 4, //revision
48. 0, //classname
50. 0, 0, //ClassInfo
52. 0, 0, //Methods
54. 0, 0, //Properties
56. 0, 0, //Enums/sets
58. 0, 0, //constructors
60. 0, //Flags
62. 0, //Signalcount
66. 0 //EOD
68. };
72. Static const Char qt_meta_stringdata_test[] = {
74. "Test\0"
76. };
80. Const Qmetaobject Test::staticmetaobject = {
82. {&qobject::staticmetaobject, qt_meta_stringdata_test,
84. Qt_meta_data_test, 0}
86. };
90. #ifdef q_no_data_relocation
92. Const Qmetaobject &test::getstaticmetaobject () { return staticmetaobject;}
94. #endif//q_no_data_relocation
98. Const Qmetaobject *test::metaobject () const
100. {
102. return Qobject::d _ptr->metaobject? Qobject::d _ptr->metaobject: &staticMetaObject;
104. }
108. void *test::qt_metacast (const char *_clname)
110. {
112. if (!_clname) return 0;
114. if (!strcmp (_clname, qt_meta_stringdata_test))
116. return static_cast<void*> (const_cast< test*> (this));
118. return Qobject::qt_metacast (_clname);
120. }
124. int Test::qt_metacall (Qmetaobject::call _c, int _id, void **_a)
126. {
128. _id = Qobject::qt_metacall (_c, _id, _a);
130. if (_id < 0)
132. return _id;
134. return _id;
136. }
138. Qt_end_moc_namespace

As you can see, Moc_test.cpp adds a lot of functions to the test class. However, we do not actually write these functions, how does it join the class? Don't forget, we still have Q_OBJECT this macro! Inside the qobjectdefs.h, find the definition of the Q_object macro:

2. #define Q_OBJECT \
4. Public: \
6. Q_object_check \
8. static const qmetaobject staticmetaobject; \
10. Q_object_getstaticmetaobject \
12. virtual const qmetaobject *metaobject () const; \
14. virtual void *qt_metacast (const char *); \
16. Qt_tr_functions \
18. virtual int Qt_metacall (qmetaobject::call, int, void * *); \
20. Private

Here's the idea: it's the expansion of the Q_object macro that allows our Test class to have these extra properties and functions. Note that the Qt_tr_functions macro is also defined here. In other words, if you want to use TR () internationalization, you must use the Q_object macro, otherwise there is no TR () function. The most important thing in this period is virtual Const Qmetaobject *metaobject () const; Function. This function returns an instance of the Qmetaobject meta-object class, through which you gain the ability to reflect the Qt class: Get the type of this object, and all of this does not require the C + + compiler's RTTI support. Qt also provides a function qobject_case () similar to C + + dynamic_cast (), and the implementation of this function does not need to be RTTI. In addition, a class that does not have a Q_object macro defined is the same type as the closest parent class. That is, if a inherits Qobject and defines Q_object,b inherits a but does not define Q_OBJECT,C inherits B, then C's Qmetaobject::classname () function will return a, not its own name. Therefore, to avoid this problem, all classes that inherit the Qobject should define Q_object macros, whether you are using a signal slot or not.

This article is from the "Bean Space" blog, make sure to keep this source http://devbean.blog.51cto.com/448512/355100

Functions of Qmake and MOC (★FIRECAT recommended ★)