Qt之Q_OBJECT详解

最新推荐文章于 2024-07-31 11:02:19 发布
最新推荐文章于 2024-07-31 11:02:19 发布
阅读量1.1w 收藏 21
点赞数 3
分类专栏： Qt

        信号和槽是Qt应用开发的基础，它可是将两个毫无关系的对象连接在一起，槽和普通的C++函数是一样的，只是当它和信号连接在一起后，当发送信号的时候，槽会自动被调用只有加入了Q_OBJECT，你才能使用QT中的signal和slot机制。

        所有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对象。


Bruce_0712
关注
专栏目录
QT宏详解Q_OBJECT、Q_PROPERTY、Q_CLASSINFO、Q_ENUM、SIGNAL、SLOT、Q_FOREACH、Q_DECLARE_INTERFACE
啊渊的专栏
10-27 590
Q_PROPERTY是Qt中用于声明对象属性的宏。它允许在C++类中定义属性，使得这些属性能够被Qt的元对象系统（Meta-Object System）识别。通过使用Q_PROPERTY宏，你可以将C++类的属性（成员变量）暴露给Qt的元对象系统，从而实现属性的动态查询、修改和通知。是 Qt 中用于将用户自定义数据类型（非 Qt 内置类型）注册到元对象系统的宏。通常，Qt 提供的信号与槽机制、属性系统等功能是基于元对象系统实现的。
【温酒读Qt】：扒扒QObject（2）—— Q_OBJECT的隐秘角落
Mr.Sugarcane
01-13 779
探寻Q_OBJECT 的隐秘
QT中的宏：Q_OBJECT
weixin_42233791的博客
08-18 2059
是什么 只有继承了QObject类的类，才具有信号槽的能力。所以，为了使用信号槽，必须继承QObject。凡是QObject类（不管是直接子类还是间接子类），都应该在第一行代码写上Q_OBJECT。不管是不是使用信号槽，都应该添加这个宏。这个宏的展开将为我们的类提供信号槽机制、国际化机制以及 Qt 提供的不基于 C++ RTTI 的反射能力。因此，如果你觉得你的类不需要使用信号槽，就不添加这个宏，就是错误的。其它很多操作都会依赖于这个宏。 注意，由于 moc 只处理头文件中的标记了Q_OBJECT的类
宏Q_OBJECT
热门推荐
liuysheng的专栏
09-27 2万+
所有QObject的派生类在官方文档中都推荐在头文件中放置宏Q_OBJECT，那么该宏到底为我们做了哪些工作？在qobjectdef.h中有下面的代码： view plainprint? #define Q_OBJECT \  public:
Q_OBJECT宏的作用
dongliqiang2006的专栏
08-15 1349
Q_OBJECT宏的作用  The Q_OBJECT macro at the beginning of the class definition is necessary for all classes that define signals
Qt之Q_OBJECT
czhzasui的博客
07-26 2万+
只有继承了QObject类的类，才具有信号槽的能力。所以，为了使用信号槽，必须继承QObject。凡是QObject类（不管是直接子类还是间接子类），都应该在第一行代码写上Q_OBJECT。不管是不是使用信号槽，都应该添加这个宏。这个宏的展开将为我们的类提供信号槽机制、国际化机制以及 Qt 提供的不基于 C++ RTTI 的反射能力。因此，如果你觉得你的类不需要使用信号槽，就不添加这个宏，就是错误...
QT线程类相关
Jayse的博客
06-09 900
文章目录线程相关线程类Qt线程三种使用：QThreada.继承QThreadQObject的moveToThreadQThreadPool + QRunnableQtConcurrent与线程相关的connect连接类型互斥锁：QMutexQMutexLocker上锁，解锁的原理：读写锁QReadWriteLock信号量QSemaphore条件变量 QWaitCondition 线程相关 线程类 Qt线程三种使用： QThread a.继承QThread 重写QThread的run()函数，由于QThrea
详解Qt之QMetaObject、qobject_cast类型转换与Q_OBJECT宏
最新发布
m0_62599305的博客
07-31 668
Qt 是一个广泛应用的 C++ 跨平台开发框架。QMetaObject 是 Qt 对象模型的重要组成部分，提供了对类的元数据访问功能。而 qobject_cast 是 Qt 中进行类型转换的工具，允许在 QObject 类及其子类之间进行安全的类型转换。本文将详细介绍 QMetaObject 的概念、作用和函数，并讨论 qobject_cast 类型转换的使用和意义。QMetaObject 和 qobject_cast 是 Qt 框架中的重要工具。
Qt中的Q_OBJECT宏解析
James_CODER的博客
09-13 231
在Qt中，Q_OBJECT宏是一个非常重要的宏定义，它在类的声明中使用，并为该类提供了一些强大的功能，如信号与槽机制、元对象系统等。通过在类的声明中添加Q_OBJECT宏，我们可以在类中使用信号和槽进行对象间的通信，并且能够在运行时获取类的元信息。注意，moc工具是由Qt提供的一个独立的预处理器，它会扫描源代码文件，找到包含Q_OBJECT宏的类，并生成相应的元对象代码。信号和槽是Qt中实现对象间通信的一种机制，通过在类中声明信号和槽，我们可以建立对象之间的连接，并在特定条件下触发信号或调用槽函数。
hello_qt.rar_QT小程序_qt hello_qt hello_qt
09-21
6. **Q_OBJECT Macro**: 在QT类中，通常需要包含`Q_OBJECT`宏，这样QT的元对象系统才能识别该类，并允许使用信号与槽。 7. **UI设计**: "hello_qt"可能还包括`.ui`文件，这是使用QT Designer创建的用户界面布局文件...
Qt中的Q_OBJECT
一缕阳光的博客
01-26 5053
在Qt中，如果一个类要使用信号/槽功能，就必须在其中声明Q_OBJECT，例如Qt5.6.1中: class MainWindow : public QMainWindow { Q_OBJECT public: explicit MainWindow(QWidget *parent = 0); ~MainWindow(); private:
QT中的Q_OBJECT
SuGuolin的博客
01-10 862
Q_OBJECT宏必须出现在类定义的私有部分，该类定义声明自己的信号和插槽，或者使用Qt的元对象系统提供的其它服务。 #include &lt;QObject&gt; class Counter : public QObject { Q_OBJECT public: Counter() { m_value = 0; } int valu...
Qt QObject 宏
baidu_41388533的博客
05-18 1126
Qt QObject 宏 QT官方文档：https://doc.qt.io/qt-5/qobject.html 成员变量 【constQMetaObjectQObject::staticMetaObject】这个变量存储类的元对象。 元对象包含关于继承QObject的类的信息。 例如类名、超类名、属性、信号和插槽。 每个包含Q_OBJECT宏的类也将有一个元对象。 元对象信息是信号/槽连接机制和属性系统所需要的。inherits()函数也使用了元对象。 如果你有一个指向对象...
Qt QObject
hw5230的博客
04-04 954
QObject是Qt类体系的唯一基类，重要性就像MFC中的CObject或Delphi中的TObject，是Qt各种功能的活水源头。QObject的大小是8，除了虚函数表（即所谓的虚表）指针需要4个字节以外，另外的4个字节是指d_ptr（指针成员变量：QObjectData *d_ptr;备注：在最新版本中，被替换为QScopedPointer d_ptr;那么，QObjectData是个什么鬼？
Qt---之Q_OBJECT详解
weixin_39609623的博客
10-08 2万+
       信号和槽是Qt应用开发的基础，它可是将两个毫无关系的对象连接在一起，槽和普通的C++函数是一样的，只是当它和信号连接在一起后，当发送信号的时候，槽会自动被调用只有加入了Q_OBJECT，你才能使用QT中的signal和slot机制。        所有QObject的派生类在官方文档中都推荐在头文件中放置宏Q_OBJECT，那么该宏到底为我们做了哪些工作？在qobjectdef.h...
Q_OBJECT解析
琅嬛福地
03-28 1971
一 Q_OBJEC 编写Qt程序久了，对Q_OBJEC宏就不陌生了，大家都知道要想用信号槽，那就得在类的私有部分加上Q_OBJECT，Qt助手的解释如下： The Q_OBJECT macro must appear in the private section of a class definition that declares its own signa...
Qt中Q_OBJECT
m0_71665186的博客
08-13 91
其实Q_OBJECT就相当于库函数一样，在代码中包含了Q_OBJECT之后，我们就可以使用Qt的相关特性，它的解释是：包含了之后，用户就可以使用 Qt元对象系统的一些特性，比如信号与槽。其实简单理解对比一下，在使用C++的时候，我们是不是要在文件头加上using namespace std;这句话，那么Qt也是一样的，添加这句话之后，我们才能使用一些常用特性。学习Qt的童鞋，肯定都会在代码中见到Q_OBJECT这个字眼，那这个是什么意思呢，有什么作用呢？
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值