Qt 动态加载动态库， QMetaObject元对象加载

最新推荐文章于 2023-01-29 09:48:41 发布
最新推荐文章于 2023-01-29 09:48:41 发布
阅读量366 收藏 1
点赞数
原文链接：http://www.cnblogs.com/warmSnowFY/p/11325857.html
版权

由于通过pro文件加载第三方库导致程序崩溃（第三方库可能存在可能不存在，新旧版本在不同路径）

而通过自己构建空库在安装时会导致覆盖可能存在的第三方库

所以修改采用了QLibrary进行动态加载；

直接上代码#include "YHPostFaceLiving.h"

#include "../YHPostFaceLivingThird/YHPostFaceLivingThird.h"
#include <QCoreApplication>
#include <QDir>
#include "stable.h"
#include <QLibrary>
#include <QProcess>
extern "C" Q_DECL_EXPORT DeviceInterface *createDC(QString param)
{
    Q_UNUSED(param);
    return new YHPostFaceLiving();
}

class YHPostFaceLiving::PrivateData{
public:

};

YHPostFaceLiving::YHPostFaceLiving()
{
#ifdef Q_OS_WIN
    interFace = NULL;
#else
    interFace = loadDevice("param", "libYHPostFaceLivingThird.so");//动态加载
#endif

    QProcess *press = new QProcess;
    press->start("ls /lib64/libtesofacecv-living.so");//new sdk path
    press->waitForFinished();
    QByteArray output = press->readAllStandardOutput();
    QString x = output;
    if(interFace && (x != "")){
        faceliving = static_cast<YHPostFaceLiving *>(interFace);//DeviceInterface是基类
        //QObject *de = dynamic_cast<DeviceInterface*>(interFace);
        if (faceliving) {
            connect(faceliving, SIGNAL(error(int)), this, SLOT(get_error(int)));
            connect(faceliving, SIGNAL(remoteParam(QString)), this, SLOT(get_remoteParam(QString)));
            connect(faceliving, SIGNAL(imageCompResult(QString)), this, SLOT(get_imageCompResult(QString)));
            connect(faceliving, SIGNAL(programResult(QString,QString)), this, SLOT(get_programResult(QString,QString)));
            connect(faceliving, SIGNAL(programFail(QString,QString)), this, SLOT(get_programFail(QString,QString)));
            connect(faceliving, SIGNAL(getImageData(QString)), this, SLOT(get_getImageData(QString)));
            connect(faceliving, SIGNAL(openComplete()), this, SLOT(get_openComplete()));
            connect(faceliving, SIGNAL(closeComplete()), this, SLOT(get_closeComplete()));
            connect(faceliving, SIGNAL(resetComplete()), this, SLOT(get_resetComplete()));
            //下一次SDK更新确定版本号，通过版本号加载新旧SDK
            //QString version = getTesoVersion();
            //if(version != "3.2.1")
            //    faceliving = NULL;
            //LOGEVENT_INFO(QString("tesoface version :%1").arg(version));
        }
    } else {
        interFace = NULL;
        faceliving = NULL;
    }
}

YHPostFaceLiving::~YHPostFaceLiving()
{
    if (libLoader) {
        libLoader->unload();
        delete libLoader;
    }
    libLoader = NULL;

    if (interFace)
        delete interFace;
    interFace = NULL;

    if (faceliving)
        delete faceliving;
    faceliving = NULL;
}

DeviceInterface* YHPostFaceLiving::loadDevice(QString param, QString libname)
{
    typedef DeviceInterface* (*createDC)(QString);
    libLoader = new QLibrary();
    QString path = QCoreApplication::applicationDirPath() + QDir::separator() +
            QString("devices") + QDir::separator() + libname;
    libLoader->setFileName(path);
    LOGEVENT_INFO("path:" + path);
    if (!libLoader->load()) {
        LOGEVENT_INFO("err:" + libLoader->errorString());
        LOGEVENT_ERR(QString("third load lib false"));
        return NULL;
    }
    if (libLoader->isLoaded()) {
        createDC fun = (createDC)libLoader->resolve("createDC");
        if (fun) {
            return fun(param);
        } else {
            LOGEVENT_ERR(QString("createDC fun is NUll"));
            return NULL;
        }
    }

    return NULL;
}

QVariant YHPostFaceLiving::executeFunc(QString func, QMap<QString, QString> &funcParams)
{
    QVariant ret;
    bool bRes = false;
    const QMetaObject* mo = faceliving->metaObject();
    if (mo) {
        QMetaMethod m = mo->method(mo->indexOfMethod(func.toLocal8Bit().data()));
        QList<QByteArray> parameterNames = m.parameterNames();
        QList<QByteArray> parameterTypes = m.parameterTypes();

        QVariant val[10] = {QVariant()};
        for (int i = 0; i < parameterNames.size(); i++) {
            QString parame = parameterNames[i];
            if (funcParams.contains(parame)) {
                QString value = funcParams.value(parame);
                QString type = parameterTypes[i];
                //类型转换函数。其实可以只用另外一个executeFunc 参数通过QVariant(param)进行转换进去
                val[i] = DeviceInterface::getParamVale(value, type.toLocal8Bit().data());
            } else {
                LOGEVENT_ERR(QString("can't not find the parameter name[%1] in fun[%2], maybe you change the function").arg(parame).arg(func));
            }
        }
        bRes = executeFunc(func, ret, val[0], val[1], val[2], val[3], val[4], val[5], val[6], val[7], val[8], val[9]);
    }

    return ret;
}

bool YHPostFaceLiving::executeFunc(QString func, QVariant &ret, QVariant val0, QVariant val1, QVariant val2, QVariant val3, QVariant val4, QVariant val5, QVariant val6, QVariant val7, QVariant val8, QVariant val9)
{
    bool bRes = false;
    const QMetaObject* mo = faceliving->metaObject();
    int nIndex = mo->indexOfMethod(func.toLocal8Bit().data());
    if (-1 != nIndex) {
        QMetaMethod m = mo->method(nIndex);
        QList<QByteArray> parameterTypes = m.parameterTypes();
        QGenericArgument val[10] = { QGenericArgument() };

        QVariant valIn[] = { val0, val1, val2, val3, val4, val5, val6, val7, val8, val9 };
        for (int i = 0; i < parameterTypes.size(); i++) {
            if (!valIn[i].convert(QMetaType::type(parameterTypes[i].data()))) {
                LOGEVENT_ERR(QString("executeFunc convert param[%1] error!").arg(i));
            }
            val[i] = QGenericArgument(parameterTypes[i].data(), &valIn[i].data_ptr().data);
        }

        //创建保存返回值的变量。
        QGenericReturnArgument retArgument = QGenericReturnArgument();
        Qt::ConnectionType connectType = Qt::AutoConnection;
        if (QString("void").compare(m.typeName())) {
            connectType = Qt::DirectConnection;
            ret = DeviceInterface::getParamVale("", m.typeName());
            retArgument = QGenericReturnArgument(m.typeName(), &ret.data_ptr().data);
            LOGEVENT_DEBUG(QString("executeFunc call function[%1] direct.").arg(func));
        }
        bRes = m.invoke(faceliving, connectType, retArgument,
                        val[0], val[1], val[2], val[3], val[4], val[5], val[6], val[7],
                val[8], val[9]);
        if (!bRes)
            LOGEVENT_ERR(QString("executeFunc call func[%1] error, object[%2]").arg(func).arg(faceliving->metaObject()->className()));
    } else {
        LOGEVENT_ERR(QString("executeFunc call func[%1] error, can't find func, object[%2]").arg(func).arg(faceliving->metaObject()->className()));
        Q_ASSERT(false);
    }
    return bRes;

}

void YHPostFaceLiving::connectEvent(QObject *dc, const QObject *receiver, const char *member)
{
    connect(dc, SIGNAL(deviceevent(QObject*,QString,QVariant,QVariant,QVariant,QVariant,QVariant,QVariant,QVariant,QVariant,QVariant,QVariant)),
            receiver, member, Qt::QueuedConnection);
}

void YHPostFaceLiving::get_remoteParam(QString result)
{
    emit_deviceevent("remoteParam(QString)", result);
}

void YHPostFaceLiving::get_imageCompResult(QString result)
{
    emit_deviceevent("imageCompResult(QString)", result);
}

void YHPostFaceLiving::get_programResult(QString serName, QString result)
{
    emit_deviceevent("programResult(QString,QString)", serName, result);
}

void YHPostFaceLiving::get_programFail(QString serName, QString result)
{
    emit_deviceevent("programFail(QString,QString)", serName, result);
}

void YHPostFaceLiving::get_getImageData(QString imageData)
{
    emit_deviceevent("getImageData(QString)", imageData);
}

void YHPostFaceLiving::get_openComplete()
{
    emit_deviceevent("openComplete()");
}

void YHPostFaceLiving::get_closeComplete()
{
    emit_deviceevent("closeComplete()");
}

void YHPostFaceLiving::get_resetComplete()
{
    emit_deviceevent("resetComplete()");
}

void YHPostFaceLiving::get_error(int error)
{
    emit_deviceevent("error(int)", error);
}
/*
int YHPostFaceLiving::analyFmlFile()
{
    if(faceliving){
        QMap<QString,QString> funcParams;
        int ret = executeFunc("analyFmlFile()", funcParams).toInt();
        return ret;
    }
    return 1;
}

void YHPostFaceLiving::loadenv(const QString &envPath)
{
    if(faceliving){
        QMap<QString,QString> funcParams;
        funcParams.insert("envPath", envPath);
        executeFunc("loadenv(QString)",funcParams);
    }
}
*/

void YHPostFaceLiving::open()
{
    if (faceliving) {
        QMap<QString, QString> funcParams;
        executeFunc("open()", funcParams);
    } else {
        emit_deviceevent("hardware_Error()");
    }
}

bool YHPostFaceLiving::openSync()
{
    if (faceliving) {
        QMap<QString, QString> funcParams;
        bool ret = executeFunc("openSync()", funcParams).toBool();
        return ret;
    } else {
        return DeviceInterface::openSync();
    }
}

void YHPostFaceLiving::close()
{
    if (faceliving) {
        QMap<QString, QString> funcParams;
        executeFunc("close()", funcParams);
    } else {
        DeviceInterface::close();
    }
}

bool YHPostFaceLiving::closeSync()
{
    if (faceliving) {
        QMap<QString, QString> funcParams;
        bool ret = executeFunc("closeSync()", funcParams).toBool();
        return ret;
    } else {
         return DeviceInterface::closeSync();
    }
}

void YHPostFaceLiving::Reset(QString)
{
    DeviceInterface::Reset();
}

long YHPostFaceLiving::winId()
{
    if (faceliving == NULL)
        return -1;

    QMap<QString,QString> funcParams;
    long ret = (long)executeFunc("winId()", funcParams).toInt();
    return ret;
}

void YHPostFaceLiving::setParent(uint winid)
{
    if (faceliving == NULL)
        return;

    QMap<QString,QString> funcParams;
    funcParams.insert("winid", QString("%1").arg(winid));
    executeFunc("setParent(uint)", funcParams);
}

void YHPostFaceLiving::setGeometry(int x, int y, int width, int height)
{
    if (faceliving == NULL)
        return;

    QMap<QString,QString> funcParams;
    funcParams.insert("x", QString("%1").arg(x));
    funcParams.insert("y", QString("%1").arg(y));
    funcParams.insert("width", QString("%1").arg(width));
    funcParams.insert("height", QString("%1").arg(height));
    executeFunc("setGeometry(int,int,int,int)", funcParams);
}

void YHPostFaceLiving::showDisplay(bool show)
{
    if (faceliving == NULL)
        return;

    QMap<QString, QString> funcParams;
    funcParams.insert("show", QString("%1").arg(show));
    executeFunc("showDisplay(bool)", funcParams);
}

QString YHPostFaceLiving::getTesoVersion()
{
    if (faceliving == NULL)
        return QString();

    QMap<QString, QString> funcParams;
    QString ret = executeFunc("getTesoVersion()", funcParams).toString();
    return ret;
}

void YHPostFaceLiving::setTesoParam(const QString &params)
{
    if (faceliving == NULL)
        return;

    QMap<QString, QString> funcParams;
    funcParams.insert("params", params);
    executeFunc("setTesoParam(QString)", funcParams);
}

QString YHPostFaceLiving::getTesoParam()
{
    if (faceliving == NULL)
        return QString();

    QMap<QString,QString> funcParams;
    QString ret = executeFunc("getTesoParam()", funcParams).toString();
    return ret;
}

void YHPostFaceLiving::setEndPoint(const QString &url)
{
    Q_UNUSED(url);
}

void YHPostFaceLiving::getRemoteParam(const QString &info)
{
    Q_UNUSED(info);
}

void YHPostFaceLiving::faceCompare(const QString &params)
{
    Q_UNUSED(params);
}

QString YHPostFaceLiving::getDevicePublicKey()
{
    if (faceliving == NULL)
        return QString();

    QMap<QString,QString> funcParams;
    QString ret = executeFunc("getDevicePublicKey()", funcParams).toString();
    return ret;
}

bool YHPostFaceLiving::importDefaultCDK(QString cdk)
{
    if (faceliving == NULL)
        return false;

    QMap<QString,QString> funcParams;
    funcParams.insert("cdk", cdk);
    bool ret = executeFunc("importDefaultCDK(QString)", funcParams).toBool();
    return ret;
}

QString YHPostFaceLiving::getCDKCheckValue()
{
    if (faceliving == NULL)
        return QString();

    QMap<QString,QString> funcParams;
    QString ret = executeFunc("getCDKCheckValue()", funcParams).toString();
    return ret;
}

bool YHPostFaceLiving::importWorkKey(QString key)
{
    if (faceliving == NULL)
        return false;

    QMap<QString, QString> funcParams;
    funcParams.insert("key", key);
    bool ret = executeFunc("importWorkKey(QString)", funcParams).toBool();
    return ret;
}

QString YHPostFaceLiving::getCameraStatus()
{
    if (faceliving == NULL)
        return QString();

    QMap<QString, QString> funcParams;
    QString ret = executeFunc("getCameraStatus()", funcParams).toString();
    return ret;
}


bool YHPostFaceLiving::echoFaceImage(bool showOrCollect)
{
#ifdef Q_OS_WIN
    return false;
#else
    if (faceliving == NULL)
        return false;

    QMap<QString,QString> funcParams;
    funcParams.insert("showOrCollect",QString("%1").arg(showOrCollect));
    bool ret = executeFunc("echoFaceImage(bool)", funcParams).toBool();
    return ret;
#endif
}


void YHPostFaceLiving::startCamera()
{
    if (faceliving == NULL)
        return;

    QMap<QString,QString> funcParams;
    executeFunc("startCamera()", funcParams);
}

void YHPostFaceLiving::stopCamera()
{
    if (faceliving == NULL)
        return;

    QMap<QString,QString> funcParams;
    executeFunc("stopCamera()", funcParams);
}

void YHPostFaceLiving::capture()
{
    if (faceliving == NULL)
        return;

    QMap<QString,QString> funcParams;
    executeFunc("capture()", funcParams);
}

QString YHPostFaceLiving::errorStr(int errNo)
{
    if (faceliving == NULL)
        return QString();

    QMap<QString, QString> funcParams;
    funcParams.insert("errNo", QString("%1").arg(errNo));
    QString ret = executeFunc("errorStr(bool)", funcParams).toString();
    return ret;
}

bool YHPostFaceLiving::setTuxedoParan(const QString &tag, const QString &value)
{
    if (faceliving == NULL)
        return false;

    QMap<QString,QString> funcParams;
    funcParams.insert("tag",tag);
    funcParams.insert("value",value);
    bool ret = executeFunc("setTuxedoParan(QString,QString)", funcParams).toBool();
    return ret;
}

QString YHPostFaceLiving::getTuxedoParan(const QString &tag)
{
    if (faceliving == NULL)
        return QString();

    QMap<QString, QString> funcParams;
    funcParams.insert("tag", tag);
    QString ret = executeFunc("getTuxedoParan(QString)", funcParams).toString();
    return ret;
}

void YHPostFaceLiving::loadEnv(const QString &envPath)
{
    if (faceliving == NULL)
        return;

    QMap<QString, QString> funcParams;
    funcParams.insert("envPath", envPath);
    executeFunc("loadEnv(QString)", funcParams);
}

int YHPostFaceLiving::tuxedoCommuncation(const QString &service, const QString &buff, const QString &reStr, int rcvlenth)
{
    if (faceliving == NULL)
        return 0;

    QMap<QString, QString> funcParams;
    funcParams.insert("service", service);
    funcParams.insert("buff", buff);
    funcParams.insert("reStr", reStr);
    funcParams.insert("rcvlenth", QString("%1").arg(rcvlenth));
    int ret = executeFunc("tuxedoCommuncation(QString,QString,QString,int)", funcParams).toInt();
    return ret;
}

bool YHPostFaceLiving::analysFmlFile(const QString &fmlpath)
{
    if (faceliving == NULL)
        return false;

    QMap<QString, QString> funcParams;
    funcParams.insert("fmlpath",fmlpath);
    bool ret = executeFunc("analysFmlFile(QString)", funcParams).toBool();
    return ret;
}

QByteArray YHPostFaceLiving::formatBuff(const QString &buff)
{
    if (faceliving == NULL)
        return QByteArray();

    QMap<QString, QString> funcParams;
    funcParams.insert("buff", buff);
    QByteArray ret = executeFunc("formatBuff(QString)", funcParams).toByteArray();
    return ret;
}

int YHPostFaceLiving::sendBuff(const QString &serName, const QByteArray &buff, const QString &reStr)
{
    if (faceliving == NULL)
        return 0;

    QMap<QString, QString> funcParams;
    funcParams.insert("serName", serName);
    funcParams.insert("buff", buff);
    funcParams.insert("reStr", reStr);
    int ret = executeFunc("sendBuff(QString,QByteArray,QString)", funcParams).toInt();
　　//int ret = executeFucn("sendBuff(QString,QByteArray,QString)", QVariant(serName), QVariant(buff), QVariant(reStr));
    return ret;
}

 

本次代码修改之后，对元对象的功能作用，接口有了一定理解。

对动态库加载有了实践。

:-D

转载于:https://www.cnblogs.com/warmSnowFY/p/11325857.html

weixin_30405421
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
QT_元对象系统, QMetaObject
WChang的博客
04-08 806
catalog元对象系统QMetaObject 元对象系统 元对象系统 的 作用 通过 (信号与槽), 来实现: 对象间的通信 运行时类型信息 动态属性 实现 (元对象系统), 依赖3部分 0, 继承 QObject 作为父类 1, 类内书写Q_OBJECT宏 2, 通过 moc编译器, 他会生成 moc_xxx.cpp (元对象)的 具体特性: signal和shot QObject::metaObject(): 与之相关联的 元对象 QMetaObject::className() 运行
qt源码学习--QMetaObject（一）
yang843094036的专栏
09-12 509
qt源码学习--QMetaObject部分
QT 添加 lib库
热门推荐
RareVer的博客
02-22 6万+
因为我在工作的过程中，使用的是第三方提供的库，但是如何将这些库添加到QT的工程中，是个问题，让我恼火了很久，怎么弄都是错的。下面，我会对这个问题，进行叙述，希望其他人第一次遇到这种问题的时候，可以轻易的解决。一.添加第三方的头文件这个问题再简单不过了，不过我还是要说下。首先，添加头文件  #include "ControlCAN.h"然后，再将这个头文件放到工程的目录下，就OK了，非常的简单二.添...
Qt 动态库的制作和调用
编程猿来如此
09-07 661
dll 创建与调用 建立 dll 项目 ①．新建项目，选择 C++ Library ②．类型选择 Shared Library ③．在头文件添加导出函数 #ifndef DLLEXAMPLE_H #define DLLEXAMPLE_H #include "dllExample_global.h" class DLLEXAMPLE_EXPORT DllExample { public: DllExample(); virtual ~DllExample(){}; virt
Qt自学之路（九）-Meta-Object系统
qq_30574227的博客
01-29 116
Qt meta-object系统介绍
Windows10下Qt动态/静态加载DLL
10-22
一种可能的方法是使用`QMetaObject::invokeMethod`调用DLL中的虚函数，但这需要DLL中类的基类继承自`QObject`并使用元对象系统。另一种方法是通过指针传递和动态分配DLL中的类实例，但这需要在DLL和应用程序之间共享...
QT 动态链接库 dll 测试代码 QT dll test
11-19
在QT Creator中，你需要创建一个新的项目，并选择“库”类别下的“动态库”模板。接着，定义你的头文件和源文件，比如`Calculator.h`和`Calculator.cpp`，在其中实现一个简单的计算器类，包含加法操作的`add`方法。 ...
VS2012中QT5.1自定plugin及动态加载plugin
12-26
在本文中，我们将深入探讨如何在Visual Studio 2012 (VS2012)环境中，使用QT 5.1框架开发自定义插件，并实现动态加载这些插件。这个过程涉及到的主要知识点包括QT插件机制、插件接口设计、VS2012与QT的集成以及动态...
QLibrary 加载动态库详细用法，封装调用方法，使用简单快速、方法使用 Qt 反射更快捷
最新发布
08-23
要加载一个动态库，你需要创建一个 QLibrary 对象并调用其 `load()` 方法，传入动态库的路径。例如： ```cpp QLibrary lib("path/to/library.dll"); if (!lib.load()) { qDebug() (); return -1; } ``` 当加载...
QT属性动画（加载动画）
03-21
QT属性动画是Qt库中的一个强大特性，它允许开发者创建出丰富、动态的效果，使得GUI界面更加生动且吸引用户。在QT中，属性动画通过QPropertyAnimation类来实现，它可以改变对象的特定属性，并随着时间线的推进平滑地...
QT 根据类名动态创建类对象（元对象反射机制）
lj19990824的博客
02-09 2388
根据类名信息动态创建对象技术，可以降低代码的耦合性和复杂性，还可以实现脚本化编程，动态解析对象，提高内存利用率和程序的灵活性 直接上代码，多改改参数就玩明白了。 通过字符串，动态创建按钮（换言之，如果这个字符串是从文件里读取出来的，是不是就是动态创建界面了） mainwindow.h #ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> #include <QByteArray> #include <
利用Qt元对象技术防止工厂模式下代码臃肿问题，QT 动态创建对象（第2种方法）
danshiming的博客
08-30 688
问题的提出： 近来要编写一个仿真液压、电力、机械的软件，如下为：液压的： 可以看到液压图中很多液压元器件，最初的设想是： 定义一个CComponent的基类，其它如上图液压业务中的各种油缸、电磁阀、压力表等都从 基类派生。然后定义一个类似如下的工厂模式，new出各种控件，如下： CComponent* CComponent::createComponentFactory(const QString& strComponentId) { if (!strCompone...
利用利用 Q_INVOKABLE 和 QMetaObject::newInstance来生成对象的新实例
hanhanluma
04-17 1651
使用Q_INVOKABLE来修饰成员函数，目的在于被修饰的成员函数能够被元对象系统所唤起。 除了为对象间的通信提供信号和槽（signals and slots）机制之外，元对象的代码还提供下列特性： QObject::metaObject()返回与该类绑定的meta-object对象。 ·QMetaObject::className()可以在运行时以字符串的形式返回类的名字，不需要C++编译器...
QML----动态创建对象
aoiyoru的博客
12-05 879
qml常规的动态创建对象
Qt元对象系统：QMetaObject
友善啊，朋友的博客
10-19 2158
Qt元对象系统：QMetaObject
浅谈Qt动态加载动态库
千里之行始于足下
09-29 5408
继续上一篇插件设计的问题，
QT 基于QMetaObject:InvokeMethod的事件订阅发布
gy827257174的博客
05-31 1652
文章目录 前言 一、QMetaObject::InvokeMethod 1.函数原型 2.函数介绍 二、事件订阅与发布 1.事件的订阅 2.事件的发布 总结 前言 在QT中，会出现同父容器的两个控件之间需要进行通讯，可以通过信号与槽函进行通讯，也可以通过指针来获取对应控件，博主在gitee上逛的时候，发现一份代码，基于QMetaObject::InvokeMethod便可以非常方便的在多个容器间进行通讯。 一、QT QMetaObject::In...
qt添加动态库.so文件的正确方法
weixin_44728745的博客
01-12 3636
qt添加动态库.so文件的正确方法
Qt调用第三方C动态库.so
xujianjun229的博客
07-13 1655
此处的编译器必须为交叉编译器： 以csdn文件为例： 1、将现有的文件编译为动态库： gcc -O -fPIC -shared -o libcsdn.so csdn.h csdn.c     1 2、将文件添加到项目路径： 将libcsdn.so文件和csdn.h文件复制到.pro文件同级目录 3、在.pro文件中添加代码： LIBS += ./libcsdn.so     1 4、在项目头文...
qt cmake 无法解析外部符号 QMetaObject
05-28
在使用 Qt 的信号槽机制、动态属性和对象间通信等功能时，都需要使用 MOC 编译器生成针对元对象系统的代码。 如果你使用 CMake 编译 Qt 项目，可以在 CMakeLists.txt 文件中添加以下代码来确保 MOC 能够正确编译： ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值