首页 / C++ / Qt and C++ Reflection，利用Qt简化C++的反射实现

Qt and C++ Reflection，利用Qt简化C++的反射实现

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Qt and C++ Reflection，利用Qt简化C++的反射实现，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10825字，纯文字阅读大概需要16分钟。

内容图文

如何在C++中实现反射机制，应该算是C++开发中经常遇到的问题之一。C++程序没有完整的元数据，也就无法实现原生的反射机制。从性能的角度讲，这样的设计不难理解，毕竟在运行时储存这些元数据需要额外的开销。不为你不使用的东西付出代价，这是C++的哲学，所以当我们需要反射机制时，我们得自己来实现它。所幸如今各种C++的反射实现已经相当成熟，比如boost::reflect，以及本文所使用的Qt。

Qt是常见的C++跨平台应用程序框架之一，除了用于开发GUI程序之外，Qt本身也是一套完整的C++库。不同于boost这样的模板库，Qt利用自带的Meta-Object Compiler（moc）来生成额外的C++代码，这些代码实现了Qt程序所必须的元数据对象。Qt中很多特有的机制，比如signals/slots，都依赖于Qt的元数据对象，可以说Qt是基于C++的一种扩展。以下我们来看两个例子，一个使用了Qt元数据对象，另一个则不使用，同样实现函数的动态调用。

首先我们来看如何使用Qt的元数据对象，我们定义了一个Service类，用来存取配置信息。首先来看头文件service.h：

            #ifndef SERVICE_H

            #define SERVICE_H

#include <QObject>
#include <QString>
#include <QVariantMap>

class Service : public QObject
{
    Q_OBJECT

public:
    QVariantMap process(const QVariantMap &request);

private:
    // request:
    //   "cmd"   : "set_config"
    //   "key"   : keyname
    //   "value" : QVariant
    // reply:
    //   "error" : error message
    Q_INVOKABLE QVariantMap process_set_config(const QVariantMap &request);

    // request:
    //   "cmd"   : "get_config"
    //   "key"   : keyname
    // reply:
    //   "error" : error message
    //   "value" : QVariant
    Q_INVOKABLE QVariantMap process_get_config(const QVariantMap &request);

    // request:
    //   "cmd"   : "get_json"
    // reply:
    //   "error" : error message
    //   "json"  : utf8 json
    Q_INVOKABLE QVariantMap process_get_json(const QVariantMap &request);

    // "key1" : QVariant
    // "key2" : QVariant
    // ...    QVariantMap m_settings;
};

#endif// SERVICE_H

这个类很简单，对外提供一个public的process函数，这个函数接受一个QVariantMap作为request，并返回一个QVariantMap作为reply。QVariantMap等于QMap<QString, QVariant>，我们用它作为万能参数。Service类内部有多个private函数，都以process开头，用来处理不同的request。我们接下来演示如何根据输入的request动态调用这些处理函数。

我们注意到Service类继承自QObject，并在类开头声明了Q_OBJECT宏。有了这个宏，moc会自动生成moc_service.cpp，Qt开发者对此应该很熟悉了，这里不再赘述。注意类中的几个处理函数之前都添加了Q_INVOKABLE宏，Qt会自动将这些函数注册到元数据对象中。如果不使用Q_INVOKABLE宏，我们也可以将这些处理函数声明为slots。除此之外，普通成员函数是无法被元数据对象调用的。

再看service.cpp：

#include "service.h"
#include <QtCore>

QVariantMap Service::process(const QVariantMap &request)
{
    QVariantMap reply;

    QString cmd = request["cmd"].toString();
    if (cmd.isEmpty())
    {
        reply["error"] = "invalid command";
        return reply;
    }

    QString methodName = QString("process_%1").arg(cmd);
    bool bret = metaObject()->invokeMethod(this,
                                           methodName.toLatin1(),
                                           Q_RETURN_ARG(QVariantMap, reply),
                                           Q_ARG(QVariantMap, request) );
    if (bret)
    {
        // printf("\nProcess finished.\n");    }
    else
    {
        reply["error"] = "no available method";
    }
    return reply;
}

QVariantMap Service::process_set_config(const QVariantMap &request)
{
    QVariantMap reply;
    reply["error"] = "success";

    QString keyname = request["key"].toString();
    if (keyname.isEmpty())
    {
        reply["error"] = "invalid keyname";
        return reply;
    }

    m_settings[keyname] = request["value"];
    return reply;
}

QVariantMap Service::process_get_config(const QVariantMap &request)
{
    QVariantMap reply;
    reply["error"] = "success";

    QString keyname = request["key"].toString();
    if (keyname.isEmpty())
    {
        reply["error"] = "invalid keyname";
        return reply;
    }

    if (m_settings.contains(keyname))
    {
        reply["value"] = m_settings[keyname];
        return reply;
    }

    reply["error"] = "key not found";
    return reply;
}

QVariantMap Service::process_get_json(const QVariantMap &)
{
    QVariantMap reply;
    reply["error"] = "success";

    QJsonObject jObj = QJsonObject::fromVariantMap(m_settings);
    QJsonDocument jDoc(jObj);

    reply["json"] = jDoc.toJson();
    return reply;
}

可以看到process函数通过request["cmd"]得到request command，再在command之前加上"process_"前缀得到处理函数的名字。比如command为"set_config"，则相应的处理函数名为"process_set_config"。之后程序再通过QMetaObject::invokeMethod来调用对应的处理函数。代码中methodName.toLatin1()是将Unicode的QString字符串转换为ASCII编码的C字符串。

之前我们利用Q_INVOKABLE宏将处理函数注册到元数据对象中，使得我们可以透过函数名来调用这些处理函数。函数的参数和返回值分别用Q_ARG和Q_RETURN_ARG宏进行了包装。最后看main.cpp：

#include "service.h"

#include <QtCore>

int main()
{
    Service service;
    QTextStream os(stdout);

    QVariantMap request1;
    request1["cmd"] = "set_config";
    request1["key"] = "search-engine";
    request1["value"] = "www.google.com";
    service.process(request1);

    QVariantMap request2;
    request2["cmd"] = "set_config";
    request2["key"] = "proxy";
    request2["value"] = "192.168.100.1";
    service.process(request2);

    QVariantMap request3;
    request3["cmd"] = "get_config";
    request3["key"] = "proxy";
    QVariantMap reply3 = service.process(request3);
    os << "\nproxy: " << reply3["value"].toString() << endl;

    QVariantMap request4;
    request4["cmd"] = "get_json";
    QVariantMap reply4 = service.process(request4);
    os << "\njson:\n" << reply4["json"].toByteArray() << endl;

    return0;
}

程序本身并没有直接调用处理函数，而是根据输入的request command得到处理函数的名字，再利用元数据对象调用真正的处理函数。这样如果需要添加对新的request command的支持，我们只需要编写新的处理函数，而现有的程序逻辑则无需修改。

程序运行结果：

proxy: 192.168.100.1

json:
{
    "proxy" : "192.168.100.1",
    "search-engine": "www.google.com"
}

以上是利用Qt实现C++反射的一个简单例子，使用了Qt元数据对象。Qt元数据对象需要moc生成额外的C++代码，我们再来看如何不使用元数据对象实现C++反射。

同样是Service这个类，我们来看头文件service.h：

            #ifndef SERVICE_H

            #define SERVICE_H

#include <QObject>
#include <QVariantMap>

class Service : public QObject
{
public:
    Service();
    QVariantMap process(const QVariantMap &request);

private:
    // request:
    //   "cmd"   : "set_config"
    //   "key"   : keyname
    //   "value" : QVariant
    // reply:
    //   "error" : error message
    QVariantMap process_set_config(const QVariantMap &);

    // request:
    //   "cmd"   : "get_config"
    //   "key"   : keyname
    // reply:
    //   "error" : error message
    //   "value" : QVariant
    QVariantMap process_get_config(const QVariantMap &);

    // request:
    //   "cmd"   : "get_json"
    // reply:
    //   "error" : error message
    //   "json"  : utf8 json
    QVariantMap process_get_json(const QVariantMap &);

    // "key1" : QVariant
    // "key2" : QVariant
    // ...    QVariantMap m_settings;
};

#endif// SERVICE_H

和之前的例子基本一样，但是没有声明Q_OBJECT宏，没有这个宏，Qt就不会用moc生成moc_service.cpp。本例无需再为处理函数加上Q_INVOKABLE宏。为了管理这些处理函数，我们需要额外定义一个模板类。来看handler.h：

            #ifndef HANDLER_H

            #define HANDLER_H

#include <QObject>
#include <QString>
#include <QVariantMap>

template <typename _type>
class EventHandler : public QObject
{
public:
    typedef QVariantMap (_type::*HandlerFuncType)(const QVariantMap &);

    // always use this function to register new handler objects
    // this function will check if all parameters are valid or notstaticbool AddHandler(QObject *parent, const QString &name, EventHandler<_type>::HandlerFuncType function) {
        if (!parent || !function || name.isEmpty())
            returnfalse;
        EventHandler<_type> *handler = new EventHandler<_type>(name, function);
        if (!handler)
            returnfalse;
        handler->setParent(parent); // event handler objects are automatically deleted when their parent is deletedreturntrue;
    }

    EventHandler<_type>::HandlerFuncType function() const { return m_function; }

private:
    // disable public constructor
    EventHandler(const QString &name, EventHandler<_type>::HandlerFuncType function) : m_function(function) { this->setObjectName(name); }

    EventHandler<_type>::HandlerFuncType m_function;
};

#endif// HANDLER_H

EventHandler继承自QObject类，QObject拥有children属性，一个QObject对象可以有多个QObject对象作为自己的children，代码中handler->setParent(parent)正是将EventHandler对象设为parent对象的child。在Qt中我们可以很方便地管理QObject对象，每一个对象都有自己的名字，使得我们可以透过名字找到对应的对象。每一个EventHandler对象都有一个指向特定成员函数的指针。调用function方法将返回该函数指针的值。

再看Service类的实现service.cpp：

#include "service.h"
#include "handler.h"

#include <QtCore>

typedef EventHandler<Service> ServiceHandler;
#define AddServiceHandler(parent, func) ServiceHandler::AddHandler(parent, #func, &Service::func)

Service::Service()
{
    AddServiceHandler(this, process_set_config);
    AddServiceHandler(this, process_get_config);
    AddServiceHandler(this, process_get_json);
}

QVariantMap Service::process(const QVariantMap &request)
{
    QVariantMap reply;

    QString cmd = request["cmd"].toString();
    if (cmd.isEmpty())
    {
        reply["error"] = "invalid command";
        return reply;
    }

    QString handlerName = QString("process_%1").arg(cmd);
    ServiceHandler *handler = this->findChild<ServiceHandler *>(handlerName, Qt::FindDirectChildrenOnly);
    if (!handler)
    {
        reply["error"] = "no available handler";
        return reply;
    }

    return ((*this).*(handler->function()))(request);
}

QVariantMap Service::process_set_config(const QVariantMap &request)
{
    QVariantMap reply;
    reply["error"] = "success";

    QString keyname = request["key"].toString();
    if (keyname.isEmpty())
    {
        reply["error"] = "invalid keyname";
        return reply;
    }

    m_settings[keyname] = request["value"];
    return reply;
}

QVariantMap Service::process_get_config(const QVariantMap &request)
{
    QVariantMap reply;
    reply["error"] = "success";

    QString keyname = request["key"].toString();
    if (keyname.isEmpty())
    {
        reply["error"] = "invalid keyname";
        return reply;
    }

    if (m_settings.contains(keyname))
    {
        reply["value"] = m_settings[keyname];
        return reply;
    }

    reply["error"] = "key not found";
    return reply;
}

QVariantMap Service::process_get_json(const QVariantMap &)
{
    QVariantMap reply;
    reply["error"] = "success";

    QJsonObject jObj = QJsonObject::fromVariantMap(m_settings);
    QJsonDocument jDoc(jObj);

    reply["json"] = jDoc.toJson();
    return reply;
}

不同于利用Qt元数据对象，现在我们需要在构造函数中手动添加所有的处理函数，当一个QObject对象析构时，它所有的children都会自动被释放，所以我们无需显式地delete这些EventHandler对象。在process函数中，通过QObject::findChild这个函数，我们能获得handlerName对应的EventHandler对象，再通过EventHandler对象中的函数指针访问真正的处理函数。

相比上一个例子利用Qt元数据对象，在本例中我们可以手动注册一个方法的别名，比如将Service类的构造函数改为如下：

            Service::Service()
{
    AddServiceHandler(
            this
            , process_set_config);
    AddServiceHandler(
            this
            , process_get_config);
    AddServiceHandler(
            this
            , process_get_json);
    ServiceHandler::AddHandler(
            this, "process_set_setting", &Service::process_set_config);
    ServiceHandler::AddHandler(this, "process_get_setting", &Service::process_get_config);
}

我们分别为Service::process_set_config和Service::process_get_config处理函数添加了别名process_set_setting和process_get_setting，之后可以用set_setting和get_setting两个命令进行调用。我们稍微修改main.cpp：

#include "service.h"

#include <QtCore>
#include <cstdio>

int main()
{
    Service service;
    QTextStream os(stdout);

    QVariantMap request1;
    request1["cmd"] = "set_setting";
    request1["key"] = "search-engine";
    request1["value"] = "www.google.com";
    service.process(request1);

    QVariantMap request2;
    request2["cmd"] = "set_config";
    request2["key"] = "proxy";
    request2["value"] = "192.168.100.1";
    service.process(request2);

    QVariantMap request3;
    request3["cmd"] = "get_setting";
    request3["key"] = "proxy";
    QVariantMap reply3 = service.process(request3);
    os << "\nproxy: " << reply3["value"].toString() << endl;

    QVariantMap request4;
    request4["cmd"] = "get_json";
    QVariantMap reply4 = service.process(request4);
    os << "\njson:\n" << reply4["json"].toByteArray() << endl;

    return0;
}

对比第一个例子，这里将request1改为set_setiing，request3改为get_setting，运行结果仍然是一样的：

proxy: 192.168.100.1

json:
{
    "proxy": "192.168.100.1",
    "search-engine": "www.google.com"
}

以上是利用Qt实现C++反射的两个例子，两个例子都实现了通过函数名动态调用处理函数。不难看出，为了动态调用处理函数，我们需要建立函数名和函数对应关系，而利用Qt的特性则简化了这一过程，使我们无需编写复杂的代码。

原文：http://www.cnblogs.com/randyyang/p/4290393.html

内容总结

以上是互联网集市为您收集整理的Qt and C++ Reflection，利用Qt简化C++的反射实现全部内容，希望文章能够帮你解决Qt and C++ Reflection，利用Qt简化C++的反射实现所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1127490.html

来源：【匿名】

【上一篇】C++测量一段代码的运行时时间【下一篇】c++有个库什么的吗?

更多 ►

【Qt and C++ Reflection，利用Qt简化C++的反射实现】教程文章相关的互联网学习教程文章

C++反射的实现【转】

原文链接：http://www.oschina.net/code/snippet_230828_9913 原文：http://www.cnblogs.com/zyzheng/p/3772548.html

Qt and C++ Reflection，利用Qt简化C++的反射实现【代码】

C++反射机制：可变参数模板实现C++反射【代码】

1. 概要 ??本文描述一个通过C++可变参数模板实现C++反射机制的方法。该方法非常实用，在Nebula高性能网络框架中大量应用，实现了非常强大的动态加载动态创建功能。Nebula框架在coding.net的仓库地址。??C++11的新特性--可变模版参数（variadic templates）是C++11新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。关于可变参数模板的原理和应用不是本文重点，不过通过本文中的例子也可充分了...

C++ 反射机制详解及实例代码

C++ 反射机制一.前言： Java有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。然而C++是不支持反射机制，虽然C++有RTTI(运行时类型识别)。但是想要实现C++对象序列化，序列化就是存储到磁盘上...

语言的反射为什么比较慢，反射存在的意义是什么？为什么C++没有反射？

1.php,java,C#都有反射，但是很多教程都说反射比较慢，那么反射为什么比较慢？2.既然他比较慢为什么这些语言都提供反射，反射对于这些语言是必须的吗？3.为什么C++没有反射，C++也是面向对象的啊回复内容：通常不是反射慢, 而是用了反射的代码做不了某些优化...反射慢的情况可能是调用时得做逆优化, 或者是语言和反射 API 的设计蛋疼, 使得反射调用必须增加一些装箱拆箱参数重排异常重抛等等额外工作.就算同一种语言, 反射快慢也是...

通过PDB文件实现非嵌入式的c++反射【代码】

//从PDB文件加载反射信息 refl_mgr.LoadDataFromFile(g_wszPdbFileName); 2、对基本数据的get/set//get instance data member CReflObject *refl_obj_bar_c; refl_mgr.GetReflObjectFromParent(refl_obj_bar, L"c", &refl_obj_bar_c);CReflValue refl_val_bar_c; refl_mgr.GetClassInstDataMember(&bar, refl_obj_bar_c, &refl_val_bar_c); printf("%d\n", refl_val_bar_c.m_Data.m_I8);//set instance data member CReflObject *...

c++的反射的demo【代码】

c++的反射的demo 一个基本例子把这个改造成：调用方不改，底层so可以改的方式一个基本例子 reflection.cpp // 工厂类的定义 #include <map> #include <iostream> #include <string> using namespace std; typedef void* (*PTRCreateObject)(void); class ClassFactory { private:map<string, PTRCreateObject> m_classMap ;ClassFactory(){}; //构造函数私有化public:void* getClassByName(string className);void registClass(str...

c++ 字段反射侵入式2【代码】

完善 reflect类添加到容器通过字符串创建结构体并修改字段值 //宏添加 #define REFLECT_CLASS(type) _struct_name=#type #define REFLECT_PROPERTY(property) register_property(property,#property);//添加到容器 #define REFLECT_REGISTER(type)template<>struct register_ioc_base<type>{private: struct register_ioc { register_ioc() { reflect::register_type<type>(#type); reflect::register_type<type>(type...

C++反射机制：可变参数模板实现C++反射（二）【代码】

1. 概要 ??2018年Bwar发布了《C++反射机制：可变参数模板实现C++反射》，文章非常实用，Bwar也见过好几个看了那篇文章后以同样方法实现反射的项目，也见过不少从我的文章抄过去连代码风格类名函数变量名什么都没改或者只是简单改一下重新发表的。被抄说明有价值，分享出来就不在意被抄，觉得文章有用就star Nebula吧，谢谢。那些用了可变参数模板实现反射的项目或文章大都是通过这种方法实现无参数版本的类对象构建，无参版本不能充...

c++反射技术

https://www.cnblogs.com/lizhanwu/p/4428990.html https://www.cnblogs.com/leijiangtao/p/12059006.html https://blog.csdn.net/qq_22660775/article/details/89713867 FC库反射机制：https://blog.51cto.com/14267585/2451131

C++反射的一种实现方式【代码】

主题 C++ 一、注册辅助类 ClassRegistry ：模板函数，用于data、module、contextdata的注册，其中的函数解析： create_object ：从RegistryMap里找到传入name对应的RegistryNode(RegistryNode保存了名字和构造函数)，调用构造函数返回。 register_class ：用传入的name和constructor注册RegistryMap,只在Register的构造函数里面调用，后面会在ClassRegister<IData> DataRegister、ClassRegister<IModule> ModuleRegister、ClassReg...

C++反射的一种实现方式【代码】

一、注册辅助类 ClassRegistry ：模板函数，用于data、module、contextdata的注册，其中的函数解析： create_object ：从RegistryMap里找到传入name对应的RegistryNode(RegistryNode保存了名字和构造函数)，调用构造函数返回。 register_class ：用传入的name和constructor注册RegistryMap,只在Register的构造函数里面调用，后面会在ClassRegister<IData> DataRegister、ClassRegister<IModule> ModuleRegister、ClassRegister<ICo...

首页 / C++ / Qt and C++ Reflection，利用Qt简化C++的反射实现

Qt and C++ Reflection，利用Qt简化C++的反射实现

内容导读

内容图文

内容总结

内容备注

内容手机端

【Qt and C++ Reflection，利用Qt简化C++的反射实现】教程文章相关的互联网学习教程文章

反射 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程