Qt Moc 文件解析

已于 2022-07-11 17:39:22 修改
阅读量1.9k 收藏 3
点赞数 2
分类专栏： Qt 源码解析 文章标签： c++ qt 源码
于 2021-06-02 15:00:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyaway403796/article/details/117465833
版权

Qt Moc文件详解

Moc文件内容

Moc 文件是Qt moc工具生成的实现文件，用于实现Qt的元对象系统

类原始代码

class ParseQObject : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int prop1 READ prop1 WRITE setProp1)// 属性1
public:
    explicit ParseQObject(QObject *parent = nullptr);
    //can create instance constructor 1
    Q_INVOKABLE ParseQObject(int constructIntParam, QObject *constructParentParam = nullptr);
signals:
    void sig1();//信号1
    void sig2(int sigParam2int);//信号2
    void sig3(char sigParam3char, int sigParam3int);//信号3
public slots:
    void slot1();//槽1
    void slot2(int slotParam2);//槽2
    void slot3(char slotParam3char, int slotPram3int);//槽3

public:
    Q_INVOKABLE void InvokeFunc();//invoke function 1
    Q_INVOKABLE int InvokeFuncWithReturn();//invoke func 2
    int prop1();
    void setProp1(int v);

private:
    int prop_1;
};

生成后Moc文件解析

QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_ParseQObject_t {
    QByteArrayData data[19];
    char stringdata0[203];
};
//QT_MOC_LITERAL宏展开
/*
	//前置宏定义
struct Q_CORE_EXPORT QArrayData
{
    QtPrivate::RefCount ref;
    int size;
    uint alloc : 31;
    uint capacityReserved : 1;

    qptrdiff offset; // in bytes from beginning of header
	
	void *data()
    {
        Q_ASSERT(size == 0
                || offset < 0 || size_t(offset) >= sizeof(QArrayData));
        return reinterpret_cast<char *>(this) + offset;
    }
}
typedef QArrayData QByteArrayData;

//qbytearry
#define Q_BASIC_ATOMIC_INITIALIZER(a) { (a) }

#define Q_REFCOUNT_INITIALIZE_STATIC { Q_BASIC_ATOMIC_INITIALIZER(-1) }

#define Q_STATIC_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, offset) \
    { Q_REFCOUNT_INITIALIZE_STATIC, size, 0, 0, offset } 
	
#define Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, offset) \
    Q_STATIC_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, offset)


/
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ParseQObject_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
	
/********
	offsetof(qt_meta_stringdata_ParseQObject_t, stringdata0)  stringdata0 在 qt_meta_stringdata_ParseQObject_t中的偏移
	宏拆开后，对应一个QByteArrayData
	{ 
		-1, 
		len, //字符串长度
		0, 0, 
		qptrdiff(offsetof(qt_meta_stringdata_ParseQObject_t, stringdata0) - idx * sizeof(QByteArrayData) + ofs ) //是对应stringdata0中此字段字符串中的首地址
	}
	//qt_meta_stringdata_ParseQObject_t, stringdata0) 字符串在结构体的偏移 256
	//qptrdiff(offsetof(qt_meta_stringdata_ParseQObject_t, stringdata0) - idx * sizeof(QByteArrayData) QByteArrayData data[16] ,数组元素[i]在结构体的偏移
	// 上式 + ofs(字符串的偏移) 即为求字符串的地址
	
	sizeof(QByteArrayData) = 16;
	假设stringdata0在qt_meta_stringdata_ParseQObject_t的偏移为19*16
	sig_2的索引为2
	则QBytearrayData data[2]= {
	-1,len,0,0,
	offset=19*16 - 2 * 16 + 18;
	为什么不是19*16 + 18呢？即为什么不是直接字符串首地址加偏移呢？
	答：因为QByteArrayData 求数据函数data定义为	
	void *data()
    {
        Q_ASSERT(size == 0
                || offset < 0 || size_t(offset) >= sizeof(QArrayData));
        return reinterpret_cast<char *>(this) + offset; 
        //此处的this 为data[2]的地址，data[2]的地址为 2 * sizeof(QByteArrayData),如果不减去data[2]的偏移，则相当于从data[2]开始+偏移+stringdata0的偏移，取到的是错误的地址
        //所以减去data[2]相对于qt_meta_stringdata_ParseQObject_t的偏移，将偏移定位到qt_meta_stringdata_ParseQObject_t的首地址0处
    }
	}
	
	data[0]的地址:  ParseQObject  			= 19*16 - 0 * 16 + 0 
	data[1]的地址:  sig1 					= 19*16 - 1 * 16 + 13 
					
					sig2
					sigParam2int
					sig3
					sigParam3char
					sigParam3int
					slot1
					slot2
					slotParam2
					slot3
					slotParam3char
					slotPram3int
					InvokeFunc
	data[15]的地址: InvokeFuncWithReturn 	= 19*16 - 15* 16 + 137 
					...
	data[18]的地址：prop1					= 19*16 - 18 * 16 + 197
********/
*/
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ParseQObject_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ParseQObject_t qt_meta_stringdata_ParseQObject = {
    {
//(0:索引, 0:对应字符串的偏移, 12:字符串的长度)  即"ParseQObject"
QT_MOC_LITERAL(0, 0, 12), // "ParseQObject" 
QT_MOC_LITERAL(1, 13, 4), // "sig1"
QT_MOC_LITERAL(2, 18, 0), // ""					//参数为空
QT_MOC_LITERAL(3, 19, 4), // "sig2"
QT_MOC_LITERAL(4, 24, 12), // "sigParam2int"	//参数名
QT_MOC_LITERAL(5, 37, 4), // "sig3"
QT_MOC_LITERAL(6, 42, 13), // "sigParam3char"
QT_MOC_LITERAL(7, 56, 12), // "sigParam3int"
QT_MOC_LITERAL(8, 69, 5), // "slot1"
QT_MOC_LITERAL(9, 75, 5), // "slot2"
QT_MOC_LITERAL(10, 81, 10), // "slotParam2"
QT_MOC_LITERAL(11, 92, 5), // "slot3"
QT_MOC_LITERAL(12, 98, 14), // "slotParam3char"
QT_MOC_LITERAL(13, 113, 12), // "slotPram3int"
QT_MOC_LITERAL(14, 126, 10), // "InvokeFunc"
QT_MOC_LITERAL(15, 137, 20), // "InvokeFuncWithReturn"
QT_MOC_LITERAL(16, 158, 17), // "constructIntParam"
QT_MOC_LITERAL(17, 176, 20), // "constructParentParam"
QT_MOC_LITERAL(18, 197, 5) // "prop1"

    },
    "ParseQObject\0sig1\0\0sig2\0sigParam2int\0"
    "sig3\0sigParam3char\0sigParam3int\0slot1\0"
    "slot2\0slotParam2\0slot3\0slotParam3char\0"
    "slotPram3int\0InvokeFunc\0InvokeFuncWithReturn\0"
    "constructIntParam\0constructParentParam\0"
    "prop1"
};
#undef QT_MOC_LITERAL
/*/
struct QMetaObjectPrivate
{
    // revision 7 is Qt 5.0 everything lower is not supported
    // revision 8 is Qt 5.12: It adds the enum name to QMetaEnum
    enum { OutputRevision = 8 }; // Used by moc, qmetaobjectbuilder and qdbus

    int revision;
    int className;
    int classInfoCount, classInfoData;
    int methodCount, methodData;
    int propertyCount, propertyData;
    int enumeratorCount, enumeratorData;
    int constructorCount, constructorData;
    int flags;
    int signalCount;
};
/*/
static const uint qt_meta_data_ParseQObject[] = {

 // content:
       8,       // revision
       0,       // classname	对应QByteArrayData data[19]中的索引
       0,    0, // classinfo
       8,   14, // methods		8:信号槽与Q_INVOKABLE函数总数, 14:对应当前数组中的索引
       1,   82, // properties
       0,    0, // enums/sets
       2,   85, // constructors
       0,       // flags
       3,       // signalCount	3:信号总数

 // signals: name, argc, parameters, tag, flags
       		  1,    0,       54,      2,  0x06 /* Public */,
       // name:1：对应QByteArrayData data[16]中的索引,
	   // argc:0:参数数量,
	   // parameters:49:参数对应当前数组中的索引,
	   // tag:2
	   // flags:0x06:方法类型 0x02 | 0x04
	   /*
		enum MethodFlags  {
			AccessPrivate = 0x00,
			AccessProtected = 0x01,
			AccessPublic = 0x02,
			AccessMask = 0x03, //mask
		 
			MethodMethod = 0x00,
			MethodSignal = 0x04,
			MethodSlot = 0x08,
			MethodConstructor = 0x0c,
			MethodTypeMask = 0x0c,
		 
			MethodCompatibility = 0x10,
			MethodCloned = 0x20,
			MethodScriptable = 0x40,
			MethodRevisioned = 0x80
		};
	   */
       3,    1,   55,    2, 0x06 /* Public */,
       5,    2,   58,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       8,    0,   63,    2, 0x0a /* Public */,
       9,    1,   64,    2, 0x0a /* Public */,
      11,    2,   67,    2, 0x0a /* Public */,

 // methods: name, argc, parameters, tag, flags
      14,    0,   72,    2, 0x02 /* Public */,
      15,    0,   73,    2, 0x02 /* Public */,

 // signals: parameters
    QMetaType::Void,
    QMetaType::Void, QMetaType::Int,    4,
    QMetaType::Void, QMetaType::Char, QMetaType::Int,    6,    7,

 // slots: parameters
 /*qt_meta_data_ParseQObject[54]*/
    QMetaType::Void,
    QMetaType::Void, QMetaType::Int,   10,
    QMetaType::Void, 	QMetaType::Char, QMetaType::Int, 12,   				13,
	//返回值类型(Void),	 参数类型(Char),	  参数类型(Int),	 12:data[19]索引,	13:data[19]索引
 // methods: parameters
    QMetaType::Void,
    QMetaType::Int,

 // constructors: parameters
 //构造函数类型，因为有默认实参，所以生成使用默认实参，和不使用默认实参两种
    0x80000000 | 2, QMetaType::Int, QMetaType::QObjectStar,   16,   17,
    0x80000000 | 2, QMetaType::Int,   16,

 // properties: name, type, flags
      18, 					QMetaType::Int, 		0x00095103,
	//18:data[19]索引，		QMetaType::Int 属性类型

 // constructors: name, argc, parameters, tag, flags
       0,    2,   74,    2, 0x0e /* Public */,
       0,    1,   79,    2, 0x2e /* Public | MethodCloned */,

       0        // eod
};
/*
	//调用方式
    enum QMetaObject::Call {
        InvokeMetaMethod,
        ReadProperty,
        WriteProperty,
        ResetProperty,
        QueryPropertyDesignable,
        QueryPropertyScriptable,
        QueryPropertyStored,
        QueryPropertyEditable,
        QueryPropertyUser,
        CreateInstance,
        IndexOfMethod,
        RegisterPropertyMetaType,
        RegisterMethodArgumentMetaType
    };
*/
void ParseQObject::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::CreateInstance) {
    	//创建对象
        switch (_id) {//id为相对索引
        case 0: { ParseQObject *_r = new ParseQObject((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< QObject*(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
        case 1: { ParseQObject *_r = new ParseQObject((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
        default: break;
        }
    } else if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ParseQObject *>(_o);
        Q_UNUSED(_t)
        switch (_id) {//id为相对索引
        case 0: _t->sig1(); break;
        case 1: _t->sig2((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 2: _t->sig3((*reinterpret_cast< char(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
        case 3: _t->slot1(); break;
        case 4: _t->slot2((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 5: _t->slot3((*reinterpret_cast< char(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
        case 6: _t->InvokeFunc(); break;
        case 7: { int _r = _t->InvokeFuncWithReturn();
            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (ParseQObject::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ParseQObject::sig1)) {
                *result = 0;
                return;
            }
        }
        {
            using _t = void (ParseQObject::*)(int );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ParseQObject::sig2)) {
                *result = 1;
                return;
            }
        }
        {
            using _t = void (ParseQObject::*)(char , int );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ParseQObject::sig3)) {
                *result = 2;
                return;
            }
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
    	//读取属性值
        auto *_t = static_cast<ParseQObject *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< int*>(_v) = _t->prop1(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    	//修改属性值
        auto *_t = static_cast<ParseQObject *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setProp1(*reinterpret_cast< int*>(_v)); break;
        default: break;
        }
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}
/*
//QMetaObject定义
struct Q_CORE_EXPORT QMetaObject
{
	struct { // private data
		const QMetaObject *superdata;
		const QByteArrayData *stringdata;
		const uint *data;
		typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
		StaticMetacallFunction static_metacall;
		const QMetaObject * const *relatedMetaObjects;
		void *extradata; //reserved for future use
	} d;
}
*/
QT_INIT_METAOBJECT const QMetaObject ParseQObject::staticMetaObject = { {
    &QObject::staticMetaObject,				//const QMetaObject *superdata;
    qt_meta_stringdata_ParseQObject.data,	//const QByteArrayData *stringdata;
    qt_meta_data_ParseQObject,				//typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
										    //StaticMetacallFunction static_metacall;
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *ParseQObject::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *ParseQObject::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_ParseQObject.stringdata0))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int ParseQObject::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 8;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 1;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}

// SIGNAL 0
void ParseQObject::sig1()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void ParseQObject::sig2(int _t1)
{
	//生成信号调用
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void ParseQObject::sig3(char _t1, int _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
flyaway403796
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
verdigris:QT无MOC
05-13
关于 此（仅标头）库可用于使用Qt创建应用程序，而无需moc（MetaObject编译器）。 它使用与Qt和模板化constexpr代码不同的一组宏在编译时生成QMetaObject。 它与Qt完全二进制兼容。 介绍项目的博客文章： : （2016） 博客文章，其中包含一些实施细节： ： （2018） 在线浏览代码： : 特拉维斯（Travis）： 输送带： 文献资料 有关介绍，请参见 。 另请参见源代码中有关宏的更详细的文档资料。 地位 Qt的几乎所有功能都可以使用。 Qt测试已被移植。 尚无法使用的功能： Q_PLUGIN_METADATA：这将需要编译为Qt的二进制json。 目前不在范围内。 QMetaMethod :: tag（）：尚未实现，可以在需要时支持，但实际上并不需要。 （甚至没有通过Qt的自动测试进行测试） Q_ENUM：有效，但需要重复每个
Qt MOC处理器 UML图
03-22
对Qt MOC的源码 UML图
[Qt]解析moc文件
最新发布
qq_47500842的博客
04-06 507
Qtmoc文件解析
Qt结构---Qt 手动生成moc 文件
weixin_39609623的博客
10-26 2269
1.问题来源        Qt自己会先把用到Qt自己的东西编译一遍，变成标准C++编译器可以识别的东西。        moc 全称是 Meta-Object Compiler，也就是“元对象编译器”。Qt 程序在交由标准编译器编译之前，先要使用 moc 分析 C++ 源文件。如果它发现在一个头文件中包含了宏 Q_OBJECT，则会生成另外一个 C++ 源文件。这个源文件中包含了 Q_OBJ...
用qt 编译qt moc
qiushangren的专栏
09-26 1591
编译qt moc
Qt Core学习日记——第一天Moc文件
sinat_36391009的博客
07-10 566
各位看官有什么意见或建议可以写到评论区，大家一起探讨。
Qt信号与槽机制的基石-MOC详解
Albert_weiku的博客
07-31 3588
上篇讲到了信号与槽就是实现的观察者模式，那具体如何生成映射表就是moc做的事情。
QT（1）：MOC元对象编译器和moc文件
qq_45088122的博客
07-23 941
MOC元对象编译器和moc文件
Qt 核心剖析: moc（转）
weiweiqiao的专栏
09-27 140
这下了解了：正是对 Q_OBJECT 宏的展开，使我们的 Test 类拥有了这些多出来的属性和函数。这个函数返回 QMetaObject 元对象类的实例，通过它，你就获得了 Qt 类的反射的能力：获取本对象的类型之类，而这一切，都不需要 C++ 编译器的 RTTI 支持。也就是说，如果 A 继承了 QObject 并且定义了 Q_OBJECT，B 继承了 A 但没有定义 Q_OBJECT，C 继承了 B，则 C 的 QMetaObject::className () 函数将返回 A，而不是本身的名字。
Qt 元对象系统--Moc文件解析
lsfreeing的专栏
12-02 1425
几篇文章 ，供参考 ​​​​​​详细分析Qt中moc文件 2.MOC文件解读（上）——MOC文件中的数据_ 3.MOC文件解读（下）——MOC文件中的函数
qtcreator编译qt程序是如何调用moc的，如何通过pro文件向moc传入参数
qiushangren的专栏
11-04 1327
qtcreator 编译qt工程 调用moc 向moc传入参数 QMAKE_MOC_OPTIONS
在qt中使用libXL
08-30
LibXL是一个可以读写Excel文件的库。它不需要Microsoft Excel和。net框架，结合了易于使用和强大的功能,获取key：https://blog.csdn.net/qq_43445867/article/details/132572402
CppMocTest.7z
01-14
moc 仅仅扫描头文件，cpp 中放置的 Q_OBJECT 不会处理，导致编译器报错，所以这时候我们还需要在源文件结尾包含"文件名.moc"，如 `#include "xxxx.moc"`，再重新 qmake->构建 即可。本次demo Qt 版本为 v5.9.6
qtcreator生成工程文件 文件列表工具
05-17
由于qtcreator本身没有添加文件夹的功能，要么去linux下生成目录，要么逐个手动添加，十分受限，此软件主要是生成工程文件lastfilelist.pro 其主要内容大致如下： QT += core gui TARGET = targettest TEMPLATE = ...
Qt（2）：MOC文件解析
oldmtn的专栏
06-03 5748
在Qt下，从QObject派生的类都会生成moc_文件。 1. 比如现在有2个文件，qmyobject.h和qmyobject.cpp，它里面有一个类QMyObject，记为版本A class QMyObject : public QObject { Q_OBJECT public: QMyObject(QObject *parent); ~QMyObject()
Qt Visual Studio生成moc文件
wjjontheway的专栏
11-29 1592
Visual Studio 转换moc文件
Qt moc文件的作用
yueye30121的专栏
03-07 4178
转载自：http://devbean.blog.51cto.com/448512/355100 前面我们说过，Qt 不是使用的“标准的” C++ 语言，而是对其进行了一定程度的“扩展”。这里我们从Qt新增加的关键字就可以看出来：signals、slots 或者 emit。所以有人会觉得 Qt 的程序编译速度慢，这主要是因为在 Qt 将源代码交给标准 C++ 编译器，如 gcc 之前，需要事先
Qt自动生成moc文件
热门推荐
xiaofengkuang的专栏
08-16 2万+
命令行生成moc文件的方式： cd C:/Qt/4.7.1/bin moc  .h文件群路径 -o 要生成的moc文件的全路径; 例如： VS中不是用addin创建的项目，自动生成moc文件的设置： 在VS的解决方案管理器里面，右键需要生成moc文件的头文件-打开属性窗口; 常规-项类型，选择自定义生成工具； 关闭属性窗口重新打开,就出现了自定义生成工具选项；
详细分析Qt中moc文件
whereisdog的博客
11-24 1万+
详细分析Qt中moc文件 　　一直想写一片详细分析Qt中moc文件的文章，今天终于是完成了。迫不及待的分享给大家，希望大家可以赏个脸，认真的看完，希望对大家的学习也有帮助。请看下面的分析Qt中moc文件的详细内容。 　　Qt 不是使用“标准的”C++语言编写，而是对其进行了一定程度的扩展。我们可以从Qt增加的关键字看出来：signals、slots或emit。但是使用gcc编译时，编译器并不认识这...
qt cmake 无法解析外部符号 QMetaObject
05-30
这个错误一般是由于缺少 moc 文件导致的。moc 文件是 Qt 的元对象编译器生成的中间文件，用于实现信号槽机制和反射等特性。 如果你使用 CMake 进行构建，可以在 CMakeLists.txt 中添加以下内容来自动生成 moc 文件： ``` set(CMAKE_AUTOMOC ON) ``` 如果你使用 qmake 进行构建，则需要在 .pro 文件中添加以下内容： ``` QT += core ``` 这样会自动启用 moc 文件的生成。同时，确保你的源文件中包含了 Q_OBJECT 宏定义，这是使用元对象特性的必要条件。 如果仍然无法解析外部符号，可能是因为 moc 文件生成失败或者编译器没有正确链接相应的库文件。你可以尝试重新生成构建文件，或者检查链接选项是否正确设置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值