宏Q_OBJECT

所有QObject的派生类在官方文档中都推荐在头文件中放置宏Q_OBJECT，那么该宏到底为我们做了哪些工作？在qobjectdef.h中有下面的代码：

view plain

1. #define Q_OBJECT \  
2. public: \  
3.   Q_OBJECT_CHECK \  
4.   static const QMetaObject staticMetaObject; \  
5.   Q_OBJECT_GETSTATICMETAOBJECT \  
6.   virtual const QMetaObject *metaObject() const; \  
7.   virtual void *qt_metacast(const char *); \  
8.   QT_TR_FUNCTIONS \  
9.   virtual int qt_metacall(QMetaObject::Call, int, void **); \  
10. private:  

首先定义了一个Q_OBJECT_CHECK宏，这个宏在Q_OBJECT宏的上方定义：

view plain

1. #define Q_OBJECT_CHECK \  
2.   template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const \  
3.   { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; }  

Q_OBJECT_CHECK实现了一个模板函数，该函数调用了qYouForgotTheQ_OBJECT_Macro的函数，qYouForgotTheQ_OBJECT_Macro在宏Q_OBJECT_CHECK下面有定义：

view plain

1. template <typename T>  
2. inline int qYouForgotTheQ_OBJECT_Macro(T, T) { return 0; }  
3. template <typename T1, typename T2>  
4. inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {}  

从返回值情况上可以看到，调用的是有int返回值的那个模板函数。但是很不明白，为什么之后还要添加一句 i=i?，刨根之后，发现Q_OBJECT_CHECK宏并没有做什么工作。

然后Q_OBJECT又帮我们定义了一个静态的元对象，

view plain

1. static const QMetaObject staticMetaObject; \  
2. Q_OBJECT_GETSTATICMETAOBJECT \  

Q_OBJECT_GETSTATICMETAOBJECT宏从名字上看就是为了获取这个元对象，确实在定义了Q_NO_DATA_RELOCATION宏的情况下，Q_OBJECT_GETSTATICMETAOBJECT宏就为我们定义了获取静态元对象的方法。

view plain

1. #ifdef Q_NO_DATA_RELOCATION  
2. #define Q_OBJECT_GETSTATICMETAOBJECT static const QMetaObject &getStaticMetaObject();  
3. #else  
4. #define Q_OBJECT_GETSTATICMETAOBJECT  
5. #endif  

之后Q_OBJECT宏又给我们定义了连个虚函数用来获取元对象指针和设置源对象。

view plain

1. virtual const QMetaObject *metaObject() const; \  
2. virtual void *qt_metacast(const char *); \  

而定义的  QT_TR_FUNCTIONS 则表示是否支持I18N。

view plain

1. #ifndef QT_NO_TRANSLATION  
2. # ifndef QT_NO_TEXTCODEC  
3. // full set of tr functions  
4. // ### Qt 5: merge overloads  
5. # define QT_TR_FUNCTIONS \  
6.   static inline QString tr(const char *s, const char *c = 0) \  
7.       { return staticMetaObject.tr(s, c); } \  
8.   static inline QString trUtf8(const char *s, const char *c = 0) \  
9.       { return staticMetaObject.trUtf8(s, c); } \  
10.   static inline QString tr(const char *s, const char *c, int n) \  
11.       { return staticMetaObject.tr(s, c, n); } \  
12.   static inline QString trUtf8(const char *s, const char *c, int n) \  
13.       { return staticMetaObject.trUtf8(s, c, n); }  
14. # else  
15. // no QTextCodec, no utf8  
16. // ### Qt 5: merge overloads  
17. # define QT_TR_FUNCTIONS \  
18.   static inline QString tr(const char *s, const char *c = 0) \  
19.       { return staticMetaObject.tr(s, c); } \  
20.   static inline QString tr(const char *s, const char *c, int n) \  
21.       { return staticMetaObject.tr(s, c, n); }  
22. # endif  
23. #else  
24. // inherit the ones from QObject  
25. # define QT_TR_FUNCTIONS  
26. #endif  

只要有所实现，tr的方法就通过静态对象staticMetaObject的tr方法来实现。最后Q_OBJECT又定义了一个虚函数

view plain

1. virtual int qt_metacall(QMetaObject::Call, int, void **);   

看名字定义，应该是用来对元对象的调用。

合起来看所有的Q_OBJECT定义，都是为了操作元对象，并没有所谓的信号和槽，属性等内容，很显然，QObject对象能够支持这些功能，必然是通过QMetaObject这个元对象来实现的。尽管QMetaObject对象的实现有些庞大，但这个是所有的QOBject中最核心的一个实现，因此需要仔细分析该对象的每个定义：

view plain

1. struct Q_CORE_EXPORT QMetaObject  
2. {  
3.   const char *className() const;                                    // 类名  
4.   const QMetaObject *superClass() const;                            // 父类的元对象  
5.   QObject *cast(QObject *obj) const;                                // 强制一个对象  
6. #ifndef QT_NO_TRANSLATION  
7.   // ### Qt 4: Merge overloads  
8.   QString tr(const char *s, const char *c) const;                       // 翻译函数  
9.   QString trUtf8(const char *s, const char *c) const;  
10.   QString tr(const char *s, const char *c, int n) const;  
11.   QString trUtf8(const char *s, const char *c, int n) const;  
12. #endif // QT_NO_TRANSLATION  
13.   int methodOffset() const;                                 // 方法偏移量  
14.   int enumeratorOffset() const;                             // 枚举偏移量  
15.   int propertyOffset() const;                                   // 属性偏移量  
16.   int classInfoOffset() const;                                  // 类信息数目  
17.   int constructorCount() const;                             // 构造函数数目  
18.   int methodCount() const;                                  // 方法数目  
19.   int enumeratorCount() const;                              // 枚举数据  
20.   int propertyCount() const;                                    // 属性数目  
21.   int classInfoCount() const;                                   // 类信息数目  
22.   int indexOfConstructor(const char *constructor) const;            // 构函函数索引  
23.   int indexOfMethod(const char *method) const;                  // 方法索引  
24.   int indexOfSignal(const char *signal) const;                  // 信号量索引  
25.   int indexOfSlot(const char *slot) const;                      // 槽索引  
26.   int indexOfEnumerator(const char *name) const;                // 枚举索引  
27.   int indexOfProperty(const char *name) const;                  // 属性索引  
28.   int indexOfClassInfo(const char *name) const;                 // 类信息索引  
29.   QMetaMethod constructor(int index) const;                 // 构造方法  
30.   QMetaMethod method(int index) const;                      // 方法  
31.   QMetaEnum enumerator(int index) const;                        // 枚举  
32.   QMetaProperty property(int index) const;                      // 属性  
33.   QMetaClassInfo classInfo(int index) const;                    // 类属性信息      
34.   QMetaProperty userProperty() const;                           // 用户属性  
35. ///  
36.   static bool checkConnectArgs(const char *signal, const char *method);  
37.   static QByteArray normalizedSignature(const char *method);  
38.   static QByteArray normalizedType(const char *type);  
39.   // internal index-based connect  
40.   static bool connect(const QObject *sender, int signal_index,  
41.                       const QObject *receiver, int method_index,  
42.                       int type = 0, int *types = 0);  
43.   // internal index-based disconnect  
44.   static bool disconnect(const QObject *sender, int signal_index,  
45.                          const QObject *receiver, int method_index);  
46.   static bool disconnectOne(const QObject *sender, int signal_index,  
47.                             const QObject *receiver, int method_index);  
48.   // internal slot-name based connect  
49.   static void connectSlotsByName(QObject *o);  
50.   // internal index-based signal activation  
51.   static void activate(QObject *sender, int signal_index, void **argv); //obsolete  
52.   static void activate(QObject *sender, int from_signal_index, int to_signal_index, void **argv); //obsolete  
53.   static void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv);  
54.   static void activate(QObject *sender, const QMetaObject *, int from_local_signal_index, int to_local_signal_index, void **argv); //obsolete  
55.   // internal guarded pointers  
56.   static void addGuard(QObject **ptr);  
57.   static void removeGuard(QObject **ptr);  
58.   static void changeGuard(QObject **ptr, QObject *o);  
59.   static bool invokeMethod(QObject *obj, const char *member,  
60.                            Qt::ConnectionType,  
61.                            QGenericReturnArgument ret,  
62.                            QGenericArgument val0 = QGenericArgument(0),  
63.                            QGenericArgument val1 = QGenericArgument(),  
64.                            QGenericArgument val2 = QGenericArgument(),  
65.                            QGenericArgument val3 = QGenericArgument(),  
66.                            QGenericArgument val4 = QGenericArgument(),  
67.                            QGenericArgument val5 = QGenericArgument(),  
68.                            QGenericArgument val6 = QGenericArgument(),  
69.                            QGenericArgument val7 = QGenericArgument(),  
70.                            QGenericArgument val8 = QGenericArgument(),  
71.                            QGenericArgument val9 = QGenericArgument());  
72.   static inline bool invokeMethod(QObject *obj, const char *member,  
73.                            QGenericReturnArgument ret,  
74.                            QGenericArgument val0 = QGenericArgument(0),  
75.                            QGenericArgument val1 = QGenericArgument(),  
76.                            QGenericArgument val2 = QGenericArgument(),  
77.                            QGenericArgument val3 = QGenericArgument(),  
78.                            QGenericArgument val4 = QGenericArgument(),  
79.                            QGenericArgument val5 = QGenericArgument(),  
80.                            QGenericArgument val6 = QGenericArgument(),  
81.                            QGenericArgument val7 = QGenericArgument(),  
82.                            QGenericArgument val8 = QGenericArgument(),  
83.                            QGenericArgument val9 = QGenericArgument())  
84.   {  
85.       return invokeMethod(obj, member, Qt::AutoConnection, ret, val0, val1, val2, val3,  
86.               val4, val5, val6, val7, val8, val9);  
87.   }  
88.   static inline bool invokeMethod(QObject *obj, const char *member,  
89.                            Qt::ConnectionType type,  
90.                            QGenericArgument val0 = QGenericArgument(0),  
91.                            QGenericArgument val1 = QGenericArgument(),  
92.                            QGenericArgument val2 = QGenericArgument(),  
93.                            QGenericArgument val3 = QGenericArgument(),  
94.                            QGenericArgument val4 = QGenericArgument(),  
95.                            QGenericArgument val5 = QGenericArgument(),  
96.                            QGenericArgument val6 = QGenericArgument(),  
97.                            QGenericArgument val7 = QGenericArgument(),  
98.                            QGenericArgument val8 = QGenericArgument(),  
99.                            QGenericArgument val9 = QGenericArgument())  
100.   {  
101.       return invokeMethod(obj, member, type, QGenericReturnArgument(), val0, val1, val2,  
102.                                val3, val4, val5, val6, val7, val8, val9);  
103.   }  
104.   static inline bool invokeMethod(QObject *obj, const char *member,  
105.                            QGenericArgument val0 = QGenericArgument(0),  
106.                            QGenericArgument val1 = QGenericArgument(),  
107.                            QGenericArgument val2 = QGenericArgument(),  
108.                            QGenericArgument val3 = QGenericArgument(),  
109.                            QGenericArgument val4 = QGenericArgument(),  
110.                            QGenericArgument val5 = QGenericArgument(),  
111.                            QGenericArgument val6 = QGenericArgument(),  
112.                            QGenericArgument val7 = QGenericArgument(),  
113.                            QGenericArgument val8 = QGenericArgument(),  
114.                            QGenericArgument val9 = QGenericArgument())  
115.   {  
116.       return invokeMethod(obj, member, Qt::AutoConnection, QGenericReturnArgument(), val0,  
117.               val1, val2, val3, val4, val5, val6, val7, val8, val9);  
118.   }  
119.   QObject *newInstance(QGenericArgument val0 = QGenericArgument(0),  
120.                        QGenericArgument val1 = QGenericArgument(),  
121.                        QGenericArgument val2 = QGenericArgument(),  
122.                        QGenericArgument val3 = QGenericArgument(),  
123.                        QGenericArgument val4 = QGenericArgument(),  
124.                        QGenericArgument val5 = QGenericArgument(),  
125.                        QGenericArgument val6 = QGenericArgument(),  
126.                        QGenericArgument val7 = QGenericArgument(),  
127.                        QGenericArgument val8 = QGenericArgument(),  
128.                        QGenericArgument val9 = QGenericArgument()) const;  
129.   enum Call {  
130.       InvokeMetaMethod,  
131.       ReadProperty,  
132.       WriteProperty,  
133.       ResetProperty,  
134.       QueryPropertyDesignable,  
135.       QueryPropertyScriptable,  
136.       QueryPropertyStored,  
137.       QueryPropertyEditable,  
138.       QueryPropertyUser,  
139.       CreateInstance  
140.   };  
141.   int static_metacall(Call, int, void **) const;  
142.   static int metacall(QObject *, Call, int, void **);  
143. #ifdef QT3_SUPPORT  
144.   QT3_SUPPORT const char *superClassName() const;  
145. #endif  
146.   struct { // private data  
147.       const QMetaObject *superdata;                         // 父类  
148.       const char *stringdata;                               // 类名  
149.       const uint *data;                                     // 任意指向数据的指针  
150.       const void *extradata;                                    // 扩展数据  
151.   } d;  
152. };  

QMetaObject就内部一个结构体对象，包含了四个部分，分别是父类对象，自己元对象的名称，以及一个指针任意值的指针数据和扩展数据，一般情况下，d.data表示的是QMetaObjectPrivate对象指针，在priv函数中可以找到一些痕迹：

view plain

1. static inline const QMetaObjectPrivate *priv(const uint* data)  
2. { return reinterpret_cast<const QMetaObjectPrivate*>(data); }  

按照Qt的实现惯例，使用Private对象做一些具体的工作，于是就有了QMetaObjectPrivate和QObjectPrivate

view plain

1. struct QMetaObjectPrivate                               // 注意是一个结构体  
2. {  
3.   int revision;                                         // 版本  
4.   int className;                                        // 类名，注意类型  
5.   int classInfoCount, classInfoData;                        // 类信息数据和数量  
6.   int methodCount, methodData;                          // 方法数据和数量  
7.   int propertyCount, propertyData;                      // 属性数据和数量  
8.   int enumeratorCount, enumeratorData;                  // 枚举数据和数量  
9.   int constructorCount, constructorData; //since revision 2     // 构造函数数据和数量      
10.   int flags; //since revision 3                             // 标记  
11.   int signalCount; //since revision 4                       // 信号量数目  
12.   // revision 5 introduces changes in normalized signatures, no new members  
13.   // 从元数据中获取QMetaObjectPrivate对象指针，从data中得到！！  
14.   static inline const QMetaObjectPrivate *get(const QMetaObject *metaobject)  
15.   { return reinterpret_cast<const QMetaObjectPrivate*>(metaobject->d.data); }   
16.   static int indexOfSignalRelative(const QMetaObject **baseObject,  
17.                                    const char* name,  
18.                                    bool normalizeStringData);  
19.   static int indexOfSlot(const QMetaObject *m,  
20.                          const char *slot,  
21.                          bool normalizeStringData);  
22.   static int originalClone(const QMetaObject *obj, int local_method_index);  
23. #ifndef QT_NO_QOBJECT  
24.   //defined in qobject.cpp  
25.   enum DisconnectType { DisconnectAll, DisconnectOne };  
26.   static bool connect(const QObject *sender, int signal_index,  
27.                       const QObject *receiver, int method_index,  
28.                       int type = 0, int *types = 0);  
29.   static bool disconnect(const QObject *sender, int signal_index,  
30.                          const QObject *receiver, int method_index,  
31.                          DisconnectType = DisconnectAll);  
32.   static inline bool disconnectHelper(QObjectPrivate::Connection *c,  
33.                                       const QObject *receiver, int method_index,  
34.                                       QMutex *senderMutex, DisconnectType);  
35. #endif  
36. };  

==================================================================

view plain

1. class Q_CORE_EXPORT QObjectPrivate : public QObjectData  
2. {  
3.   Q_DECLARE_PUBLIC(QObject)  
4. public:  
5.   struct ExtraData                      // 定义额外数据  
6.   {  
7.       ExtraData() {}  
8. #ifndef QT_NO_USERDATA  
9.       QVector<QObjectUserData *> userData;  
10. #endif  
11.       QList<QByteArray> propertyNames;                    // 属性名列表  
12.       QList<QVariant> propertyValues;                     // 属性值    
13.   };  
14.   struct Connection                                     // 定义连接信息  
15.   {  
16.       QObject *sender;                                  // 发送者  
17.       QObject *receiver;                                    // 接受者  
18.       int method;                                           // 方法  
19.       uint connectionType : 3; // 0 == auto, 1 == direct, 2 == queued, 4 == blocking  
20.       QBasicAtomicPointer<int> argumentTypes;             // 参数类型  
21.       // The next pointer for the singly-linked ConnectionList  
22.       Connection *nextConnectionList;                       // 下一个连接对象列表  
23.       //senders linked list  
24.       Connection *next;                                 // 下一个连接  
25.       Connection **prev;                                    // 上一个连接  
26.       ~Connection();  
27.   };  
28.   // ConnectionList is a singly-linked list  
29.   struct ConnectionList {                                   // 定义连接列表  
30.       ConnectionList() : first(0), last(0) {}                 
31.       Connection *first;                                    // 连接首  
32.       Connection *last;                                 // 连接尾  
33.   };  
34.   struct Sender                                         // 定义发送者  
35.   {  
36.       QObject *sender;                                  // 发送者  
37.       int signal;                                           // 信号  
38.       int ref;                                              // 引用计数  
39.   };  
40.   QObjectPrivate(int version = QObjectPrivateVersion);  
41.   virtual ~QObjectPrivate();  
42.   void deleteChildren();                                        // 删除所有子节点  
43.   void setParent_helper(QObject *);                             // 设置父节点  
44.   void moveToThread_helper();                                   // 转到某个线程中  
45.   void setThreadData_helper(QThreadData *currentData, QThreadData *targetData); // 设置线程数据  
46.   void _q_reregisterTimers(void *pointer);                          // 设置注册时间  
47.   bool isSender(const QObject *receiver, const char *signal) const; // 判断信号量是否为发送者  
48.   QObjectList receiverList(const char *signal) const;               // 接受信号的对象列表  
49.   QObjectList senderList() const;                               // 发出信息列表  
50.   void addConnection(int signal, Connection *c);                // 添加一个信号连接  
51.   void cleanConnectionLists();                              // 清理连接列表  
52. #ifdef QT3_SUPPORT  
53.   void sendPendingChildInsertedEvents();  
54.   void removePendingChildInsertedEvents(QObject *child);  
55. #endif  
56.   static inline Sender *setCurrentSender(QObject *receiver,  
57.                                   Sender *sender);          // 设置当前发送者  
58.   static inline void resetCurrentSender(QObject *receiver,  
59.                                  Sender *currentSender,  
60.                                  Sender *previousSender);   // 重置当前发送者  
61.   static int *setDeleteWatch(QObjectPrivate *d, int *newWatch); // 设置删除监听  
62.   static void resetDeleteWatch(QObjectPrivate *d, int *oldWatch, int deleteWatch);  // 重置删除监听  
63.   static void clearGuards(QObject *);                   // 清除管理者  
64.   static QObjectPrivate *get(QObject *o) {          // 从QObject对象中获取QObjectPrivate    
65.       return o->d_func();  
66.   }  
67.   int signalIndex(const char *signalName) const;            // 信号索引  
68.   inline bool isSignalConnected(uint signalIdx) const;      // 判断是否为信号连接  
69. public:  
70.   QString objectName;                                   // 对象名字  
71.   ExtraData *extraData;   // extra data set by the user     // 额外数据  
72.   QThreadData *threadData; // id of the thread that owns the object     // 线程数据  
73.   QObjectConnectionListVector *connectionLists;                 // 连接列表数组  
74.   Connection *senders;    // linked list of connections connected to this object  // 发送者连接  
75.   Sender *currentSender;  // object currently activating the object         // 当前发送者  
76.   mutable quint32 connectedSignals[2];                      // 连接信号  
77. #ifdef QT3_SUPPORT  
78.   QList<QObject *> pendingChildInsertedEvents;  
79. #else  
80.   // preserve binary compatibility with code compiled without Qt 3 support  
81.   // keeping the binary layout stable helps the Qt Creator debugger  
82.   void *unused;                                     // 保留  
83. #endif  
84.   QList<QPointer<QObject> > eventFilters;  
85.   union {  
86.       QObject *currentChildBeingDeleted;                // 当前子节点被删除  
87.       QAbstractDeclarativeData *declarativeData; //extra data used by the declarative module  
88.   };  
89.   // these objects are all used to indicate that a QObject was deleted  
90.   // plus QPointer, which keeps a separate list  
91.   QAtomicPointer<QtSharedPointer::ExternalRefCountData> sharedRefcount; // 共享引用计数  
92.   int *deleteWatch;         // 删除监听者  
93. };  

QObjectPrivate从QObjectData派生下来：

view plain

1. class  
2. #if defined(__INTEL_COMPILER) && defined(Q_OS_WIN)  
3. Q_CORE_EXPORT  
4. #endif  
5. QObjectData {  
6. public:  
7.   virtual ~QObjectData() = 0;  
8.   QObject *q_ptr;                               // 当前指向的QOBject  
9.   QObject *parent;                              // 指向的QObject父类   
10.   QObjectList children;                         // 孩儿们  
11.   uint isWidget : 1;                                // 是否为widget的标记   
12.   uint pendTimer : 1;                           // 开启时钟  
13.   uint blockSig : 1;                                // 阻塞信号标记  
14.   uint wasDeleted : 1;                          // 是否参数标记  
15.   uint ownObjectName : 1;                       // 是否含有对象名标记  
16.   uint sendChildEvents : 1;                     // 发送到子对象时间标记  
17.   uint receiveChildEvents : 1;                  // 接受子对象时间标记  
18.   uint inEventHandler : 1;                      // 是否有事件句柄标记  
19.   uint inThreadChangeEvent : 1;                 // 线程更改时间标记  
20.   //是否有守护标记  
21.   uint hasGuards : 1; //true iff there is one or more QPointer attached to this object  
22.   uint unused : 22;                             // 保留  
23.   int postedEvents;                             // 发送的数据  
24.   QMetaObject *metaObject; // assert dynamic            // 元对象  
25. };  

QObjectData保留一些了基本的数据信息

view plain

1. #define Q_DECLARE_PUBLIC(Class)                                   \  
2.   inline Class* q_func() { return static_cast<Class *>(q_ptr); } \  
3.   inline const Class* q_func() const { return static_cast<const Class *>(q_ptr); } \  
4.   friend class Class;  

在元对象中获取类名和父类的方式很简单，直接即可。

view plain

1. inline const char *QMetaObject::className() const  
2. { return d.stringdata; }  
3. inline const QMetaObject *QMetaObject::superClass() const  
4. { return d.superdata; }  

元对象中cast函数的实现

view plain

1. QObject *QMetaObject::cast(QObject *obj) const  
2. {  
3.   if (obj) {  
4.       const QMetaObject *m = obj->metaObject();  
5.       do {  
6.           if (m == this)  
7.               return const_cast<QObject*>(obj);  
8.       } while ((m = m->d.superdata));  
9.   }  
10.   return 0;  
11. }  

如果对象obj存在，则对每一个obj的父类的源对象进行转换，如果是当前的元对象，则进行返回，否则返回0，也就是cast函数是在obj中查找当前元对象所在的QObject对象。