宏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对象。


转自:http://blog.csdn.net/liuysheng/article/details/6828221

posted @ 2012-03-09 14:40  hnrainll  阅读(4854)  评论(0)  编辑  收藏  举报