我希望能够自省 C++ 类的名称、内容（即成员及其类型）等。我在这里说的是本地 C++，而不是托管 C++，它有反射。我意识到 C++ 使用 RTTI 提供了一些有限的信息。哪些额外的库（或其他技术）可以提供这些信息？
Nick
问问题
244960 次
28 回答
311
您需要做的是让预处理器生成有关字段的反射数据。此数据可以存储为嵌套类。
首先，为了在预处理器中更容易和更清晰地编写它，我们将使用类型化表达式。类型化表达式只是将类型放在括号中的表达式。所以int x你会写而不是写(int) x。这里有一些方便的宏来帮助输入表达式：
#define REM(...) __VA_ARGS__
#define EAT(...)
// Retrieve the type
#define TYPEOF(x) DETAIL_TYPEOF(DETAIL_TYPEOF_PROBE x,)
#define DETAIL_TYPEOF(...) DETAIL_TYPEOF_HEAD(__VA_ARGS__)
#define DETAIL_TYPEOF_HEAD(x, ...) REM x
#define DETAIL_TYPEOF_PROBE(...) (__VA_ARGS__),
// Strip off the type
#define STRIP(x) EAT x
// Show the type without parenthesis
#define PAIR(x) REM x
接下来，我们定义一个REFLECTABLE宏来生成每个字段的数据（加上字段本身）。这个宏将被这样调用：
REFLECTABLE
(
(const char *) name,
(int) age
)
因此，使用Boost.PP我们遍历每个参数并生成如下数据：
// A helper metafunction for adding const to a type
template<class M, class T>
struct make_const
{
typedef T type;
};
template<class M, class T>
struct make_const<const M, T>
{
typedef typename boost::add_const<T>::type type;
};
#define REFLECTABLE(...) \
static const int fields_n = BOOST_PP_VARIADIC_SIZE(__VA_ARGS__); \
friend struct reflector; \
template<int N, class Self> \
struct field_data {}; \
BOOST_PP_SEQ_FOR_EACH_I(REFLECT_EACH, data, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))
#define REFLECT_EACH(r, data, i, x) \
PAIR(x); \
template<class Self> \
struct field_data<i, Self> \
{ \
Self & self; \
field_data(Self & self) : self(self) {} \
\
typename make_const<Self, TYPEOF(x)>::type & get() \
{ \
return self.STRIP(x); \
}\
typename boost::add_const<TYPEOF(x)>::type & get() const \
{ \
return self.STRIP(x); \
}\
const char * name() const \
{\
return BOOST_PP_STRINGIZE(STRIP(x)); \
} \
}; \
这样做是生成一个常量fields_n，该常量是类中可反射字段的数量。然后它专门field_data针对每个领域。它也是reflector类的朋友，这样即使它们是私有的，它也可以访问这些字段：
struct reflector
{
//Get field_data at index N
template<int N, class T>
static typename T::template field_data<N, T> get_field_data(T& x)
{
return typename T::template field_data<N, T>(x);
}
// Get the number of fields
template<class T>
struct fields
{
static const int n = T::fields_n;
};
};
现在迭代我们使用访问者模式的字段。我们创建一个从 0 到字段数的 MPL 范围，并访问该索引处的字段数据。然后它将字段数据传递给用户提供的访问者：
struct field_visitor
{
template<class C, class Visitor, class I>
void operator()(C& c, Visitor v, I)
{
v(reflector::get_field_data<I::value>(c));
}
};
template<class C, class Visitor>
void visit_each(C & c, Visitor v)
{
typedef boost::mpl::range_c<int,0,reflector::fields<C>::n> range;
boost::mpl::for_each<range>(boost::bind<void>(field_visitor(), boost::ref(c), v, _1));
}
现在，在关键时刻，我们将它们放在一起。下面是我们如何定义一个Person可反射的类：
struct Person
{
Person(const char *name, int age)
:
name(name),
age(age)
{
}
private:
REFLECTABLE
(
(const char *) name,
(int) age
)
};
print_fields这是一个使用反射数据迭代字段的通用函数：
struct print_visitor
{
template<class FieldData>
void operator()(FieldData f)
{
std::cout << f.name() << "=" << f.get() << std::endl;
}
};
template<class T>
void print_fields(T & x)
{
visit_each(x, print_visitor());
}
print_fields使用可反射Person类的示例：
int main()
{
Person p("Tom", 82);
print_fields(p);
return 0;
}
哪个输出：
name=Tom
age=82
瞧，我们刚刚用 C++ 实现了反射，代码不到 100 行。
于 2012-07-31T20:07:50.063 回答
108
有两种reflection游泳方式。
- 通过迭代类型的成员、枚举其方法等进行检查。
这在 C++ 中是不可能的。 - 通过检查类类型（类、结构、联合）是否具有方法或嵌套类型来检查是否派生自另一个特定类型。
这种事情在 C++ 中使用template-tricks. 用于boost::type_traits许多事情（例如检查类型是否为整数）。要检查成员函数是否存在，请使用Is it possible to write a template to check for a function's exist? . 要检查某个嵌套类型是否存在，请使用普通SFINAE。
如果您正在寻找实现 1) 的方法，比如查看一个类有多少方法，或者喜欢获取类 id 的字符串表示，那么恐怕没有标准 C++ 方法可以做到这一点。你必须使用
- 像 Qt Meta Object Compiler 这样的 Meta Compiler，它可以翻译您的代码并添加额外的元信息。
- 一个由宏组成的框架，允许您添加所需的元信息。你需要告诉框架所有的方法、类名、基类和它需要的一切。
C++ 的设计考虑了速度。如果你想要像 C# 或 Java 那样的高级检查，那么恐怕我不得不告诉你，没有一些努力是没有办法的。
于 2008-11-24T14:30:07.537 回答
59
我会喜欢一匹小马，但小马不是免费的。:-p
http://en.wikibooks.org/wiki/C%2B%2B_Programming/RTTI是您将获得的。像您正在考虑的反射——在运行时可用的完全描述性元数据——默认情况下对于 C++ 是不存在的。
于 2008-09-03T11:04:56.540 回答
45
开箱即用的 C++ 不支持反射。这很可悲，因为它使防御性测试变得痛苦。
有几种方法可以进行反射：
第一个链接看起来最有前途（使用 mod 来 clang），第二个讨论了一些技术，第三个是使用 gcc 的不同方法：
现在有一个 C++ 反射工作组。查看 C++14 @ CERN 的新闻：
编辑 17 年 8 月 13 日：
自最初的帖子以来，反思已经有了许多潜在的进步。以下提供了有关各种技术和状态的更多详细信息和讨论：
然而，在不久的将来，C++ 中的标准化反射方法看起来并不乐观，除非社区对支持 C++ 中的反射有更多的兴趣。
以下根据上次 C++ 标准会议的反馈详细说明当前状态：
编辑 2017 年 13 月 12 日
反射看起来正在向 C++ 20 或更可能是 TSR 发展。然而运动缓慢。
编辑 15/09/2018
TS 草案已发送给国家机构进行投票。
文本可以在这里找到：https ://github.com/cplusplus/reflection-ts
编辑 2019 年 11 月 7 日
反射 TS 功能完整，并在夏季（2019 年）发布评论和投票。
元模板编程方法将替换为更简单的编译时代码方法（未反映在 TS 中）。
编辑 2020 年 10 月 2 日
这里有一个支持 Visual Studio 中反射 TS 的请求：
作者 David Sankel 谈 TS：
编辑 2020 年 3 月 17 日
反思方面正在取得进展。可在此处找到来自“2020-02 布拉格 ISO C++ 委员会旅行报告”的报告：
可以在此处找到有关 C++23 正在考虑的内容的详细信息（包括关于反射的简短部分）：
编辑 2020 年 6 月 4 日
Jeff Preshing 发布了一个名为“Plywood”的新框架，其中包含运行时反射机制。更多详情可在这找到：
到目前为止，这些工具和方法看起来是最完善和最容易使用的。
编辑 2020 年 7 月 12 日
Clang 实验反射叉：https ://github.com/lock3/meta/wiki
有趣的反射库，使用 clang 工具库提取信息以进行简单反射，无需添加宏：https ://github.com/chakaz/reflang
编辑 2021 年 2 月 24 日
一些额外的 clang 工具方法：
编辑 2021 年 8 月 25 日
youtube https://www.youtube.com/watch?v=60ECEc-URP8上的 ACCU 在线演讲也非常值得一听，它讨论了当前对该标准的提议以及基于 clang 的实现。
看：
- https://github.com/lock3/meta，分支论文/p2320
- 编译器资源管理器：https : //cppx.godbolt.org/ 使用 p2320 主干作为编译器版本。
于 2012-11-04T08:15:37.670 回答
40
该信息确实存在 - 但不是您需要的格式，并且仅当您导出您的课程时。这适用于Windows，我不知道其他平台。使用存储类说明符，例如：
class __declspec(export) MyClass
{
public:
void Foo(float x);
}
这使得编译器将类定义数据构建到 DLL/Exe 中。但它不是一种可以轻松用于反射的格式。
在我的公司，我们构建了一个库来解释此元数据，并允许您反映一个类，而无需在类本身中插入额外的宏等。它允许按如下方式调用函数：
MyClass *instance_ptr=new MyClass;
GetClass("MyClass")->GetFunction("Foo")->Invoke(instance_ptr,1.331);
这有效地做到了：
instance_ptr->Foo(1.331);
Invoke(this_pointer,...) 函数具有可变参数。显然，通过以这种方式调用函数，您绕过了诸如 const-safety 之类的事情，因此这些方面被实现为运行时检查。
我确信语法可以改进，到目前为止它只适用于 Win32 和 Win64。我们发现它对于为类提供自动 GUI 接口、在 C++ 中创建属性、与 XML 进行流式传输等非常有用，并且不需要从特定的基类派生。如果有足够的需求，也许我们可以将其成型以供发布。
于 2009-08-19T14:19:04.263 回答
14
我会推荐使用Qt。
有开源许可证和商业许可证。
于 2008-09-03T13:06:38.573 回答
14
您需要查看您正在尝试做什么，以及 RTTI 是否会满足您的要求。我已经为一些非常具体的目的实现了我自己的伪反射。例如，我曾经希望能够灵活配置模拟输出的内容。它需要向将要输出的类添加一些样板代码：
namespace {
static bool b2 = Filter::Filterable<const MyObj>::Register("MyObject");
}
bool MyObj::BuildMap()
{
Filterable<const OutputDisease>::AddAccess("time", &MyObj::time);
Filterable<const OutputDisease>::AddAccess("person", &MyObj::id);
return true;
}
第一次调用将此对象添加到过滤系统，过滤系统调用该BuildMap()方法以确定哪些方法可用。
然后，在配置文件中，您可以执行以下操作：
FILTER-OUTPUT-OBJECT MyObject
FILTER-OUTPUT-FILENAME file.txt
FILTER-CLAUSE-1 person == 1773
FILTER-CLAUSE-2 time > 2000
通过一些涉及的模板魔术boost，这会在运行时（读取配置文件时）转换为一系列方法调用，因此相当有效。除非您确实需要，否则我不建议您这样做，但是，当您这样做时，您可以做一些非常酷的事情。
于 2008-09-03T15:00:35.990 回答
11
我曾经做过类似您所追求的事情，虽然可以获得某种程度的反思和访问更高级别的功能，但维护头痛可能不值得。我的系统用于通过类似于 Objective-C 的消息传递和转发概念的委托将 UI 类与业务逻辑完全分离。做到这一点的方法是创建一些能够映射符号的基类（我使用了一个字符串池，但如果你更喜欢速度和编译时错误处理而不是完全的灵活性，你可以使用枚举来做到这一点）到函数指针（实际上不是纯函数指针，但类似于 Boost 在 Boost.Function 中的功能——我当时无法访问）。只要您有一些能够表示任何值的通用基类，您就可以对您的成员变量执行相同的操作。整个系统是对键值编码和委托的毫不掩饰的抄袭，有一些副作用可能值得花费大量时间来让使用该系统的每个类都将其所有方法和成员与合法调用相匹配: 1) 任何类都可以调用任何其他类的任何方法，而无需包含头文件或编写假基类，因此可以为编译器预定义接口；2) 成员变量的 getter 和 setter 很容易使线程安全，因为更改或访问它们的值总是通过所有对象的基类中的 2 个方法来完成。整个系统是对键值编码和委托的毫不掩饰的抄袭，有一些副作用可能值得花费大量时间来让使用该系统的每个类都将其所有方法和成员与合法调用相匹配: 1) 任何类都可以调用任何其他类的任何方法，而无需包含头文件或编写假基类，因此可以为编译器预定义接口；2) 成员变量的 getter 和 setter 很容易使线程安全，因为更改或访问它们的值总是通过所有对象的基类中的 2 个方法来完成。整个系统是对键值编码和委托的毫不掩饰的抄袭，有一些副作用可能值得花费大量时间来让使用该系统的每个类都将其所有方法和成员与合法调用相匹配: 1) 任何类都可以调用任何其他类的任何方法，而无需包含头文件或编写假基类，因此可以为编译器预定义接口；2) 成员变量的 getter 和 setter 很容易使线程安全，因为更改或访问它们的值总是通过所有对象的基类中的 2 个方法来完成。1) 任何类都可以在任何其他类上调用任何方法，而无需包含头文件或编写假基类，因此可以为编译器预定义接口；2) 成员变量的 getter 和 setter 很容易使线程安全，因为更改或访问它们的值总是通过所有对象的基类中的 2 个方法来完成。1) 任何类都可以在任何其他类上调用任何方法，而无需包含头文件或编写假基类，因此可以为编译器预定义接口；2) 成员变量的 getter 和 setter 很容易使线程安全，因为更改或访问它们的值总是通过所有对象的基类中的 2 个方法来完成。
它还导致了一些非常奇怪的事情的可能性，这些事情在 C++ 中并不容易。例如，我可以创建一个 Array 对象，其中包含任何类型的任意项，包括它自己，并通过将消息传递给所有数组项并收集返回值来动态创建新数组（类似于 Lisp 中的 map）。另一个是键值观察的实现，由此我能够设置 UI 以立即响应后端类成员的变化，而不是不断地轮询数据或不必要地重绘显示。
您可能更感兴趣的是，您还可以转储为类定义的所有方法和成员，并且以字符串形式转储。
系统的缺点可能会阻止您打扰：添加所有消息和键值非常繁琐；它比没有任何反射要慢；你会越来越讨厌看到你的代码库boost::static_pointer_cast并boost::dynamic_pointer_cast充满激情；强类型系统的局限性仍然存在，您实际上只是将它们隐藏了一点，所以它并不那么明显。字符串中的错别字也不是一个有趣或容易发现的惊喜。
至于如何实现这样的事情：只需使用指向一些公共基础的共享和弱指针（我的非常富有想象力地称为“对象”）并为您想要使用的所有类型派生。我建议安装 Boost.Function 而不是按照我的方式安装，即使用一些自定义废话和大量丑陋的宏来包装函数指针调用。由于所有内容都已映射，因此检查对象只需遍历所有键即可。由于我的课程基本上尽可能接近直接使用 C++ 的 Cocoa，如果你想要类似的东西，那么我建议使用 Cocoa 文档作为蓝图。
于 2008-11-27T21:41:28.863 回答
8
我在 C++ 时代所知道的两种类似反射的解决方案是：
1) 使用 RTTI，如果您能够让所有类都派生自“对象”基类，它将为您提供构建类似反射的行为的引导程序。该类可以提供一些方法，如 GetMethod、GetBaseClass 等。至于这些方法如何工作，您需要手动添加一些宏来装饰您的类型，这些宏在幕后在类型中创建元数据以提供对 GetMethods 等的答案。
2) 另一种选择，如果您有权访问编译器对象，则使用DIA SDK。如果我没记错的话，这可以让您打开 pdb，其中应该包含 C++ 类型的元数据。做你需要的可能就足够了。例如，此页面显示了如何获取类的所有基本类型。
不过，这两种解决方案都有些难看！没有什么比一点 C++ 更能让您欣赏 C# 的奢华了。
祝你好运。
于 2008-09-03T12:13:09.620 回答
6
我认为您可能会发现 Dominic Filion 的文章“在 C++ 中使用模板进行反射”很有趣。它位于Game Programming Gems 5的第 1.4 节中。不幸的是，我没有随身携带我的副本，但请寻找它，因为我认为它解释了您的要求。
于 2008-11-24T14:20:47.087 回答
6
这个问题现在有点老了（不知道为什么我今天一直在问老问题）但我在考虑引入编译时反射的BOOST_FUSION_ADAPT_STRUCT 。
当然，这取决于您将其映射到运行时反射，这不会太容易，但是在这个方向上是可能的，而在相反的方向上是不可能的 :)
我真的认为一个封装宏的宏BOOST_FUSION_ADAPT_STRUCT可以生成必要的方法来获得运行时行为。
于 2010-11-12T17:05:53.660 回答
5
反射本质上是关于编译器决定在运行时代码可以查询的代码中留下的足迹。C++ 以不为不使用的东西付费而闻名。因为大多数人不使用/不想要反射，C++ 编译器通过不记录任何内容来避免成本。
因此，C++ 不提供反射，并且作为一般规则自己“模拟”它并不容易，正如其他答案所指出的那样。
在“其他技术”下，如果您没有带反射的语言，请获取可以在编译时提取您想要的信息的工具。
我们的DMS 软件再工程工具包是由显式语言定义参数化的通用编译器技术。它具有 C、C++、Java、COBOL、PHP 等语言定义。
对于 C、C++、Java 和 COBOL 版本，它提供对解析树和符号表信息的完整访问。该符号表信息包括您可能希望从“反射”中获得的数据类型。如果您的目标是枚举一组字段或方法并对其进行处理，则可以使用 DMS 根据您在符号表中找到的内容以任意方式转换代码。
于 2010-12-30T11:02:46.667 回答
5
于 2013-10-29T12:52:23.147 回答
4
Ponder是一个 C++ 反射库，用于回答这个问题。我考虑了这些选项并决定自己制作，因为我找不到一个能满足我所有条件的选项。
尽管这个问题有很好的答案，但我不想使用大量的宏，或者依赖 Boost。Boost 是一个很棒的库，但是有很多小型定制 C++0x 项目更简单，编译时间更快。能够在外部装饰一个类也有好处，比如包装一个（还没有？）支持 C++11 的 C++ 库。它是 CAMP 的分支，使用 C++11，不再需要 Boost。
于 2015-12-31T20:41:01.993 回答
3
您可以在此处找到另一个库：http ://www.garret.ru/cppreflection/docs/reflect.html 它支持两种方式：从调试信息中获取类型信息并让程序员提供此信息。
我也对我的项目的反射感兴趣并找到了这个库，我还没有尝试过，但尝试了这个人的其他工具，我喜欢它们的工作方式:-)
于 2011-07-28T08:45:18.447 回答
3
如果您正在寻找相对简单的 C++ 反射 - 我从各种来源收集了宏/定义，并评论了它们的工作原理。您可以从这里下载头文件：
https://github.com/tapika/TestCppReflect/blob/master/MacroHelpers.h
一组定义，加上它上面的功能：
https://github.com/tapika/TestCppReflect/blob/master/CppReflect.h https://github.com/tapika/TestCppReflect/blob/master/CppReflect.cpp https://github.com/tapika/TestCppReflect/ blob/master/TypeTraits.h
示例应用程序也位于 git 存储库中，在这里： https ://github.com/tapika/TestCppReflect/
我将在此处部分复制并解释：
#include "CppReflect.h"
using namespace std;
class Person
{
public:
// Repack your code into REFLECTABLE macro, in (<C++ Type>) <Field name>
// form , like this:
REFLECTABLE( Person,
(CString) name,
(int) age,
...
)
};
void main(void)
{
Person p;
p.name = L"Roger";
p.age = 37;
...
// And here you can convert your class contents into xml form:
CStringW xml = ToXML( &p );
CStringW errors;
People ppl2;
// And here you convert from xml back to class:
FromXml( &ppl2, xml, errors );
CStringA xml2 = ToXML( &ppl2 );
printf( xml2 );
}
REFLECTABLEdefine 使用类名 + 字段名和offsetof- 来标识特定字段位于内存中的哪个位置。我试图尽可能地使用 .NET 术语，但是 C++ 和 C# 是不同的，所以它不是一对一的。整个 C++ 反射模型驻留在TypeInfo类FieldInfo中。
我使用 pugi xml 解析器将演示代码提取到 xml 并从 xml 恢复。
因此演示代码产生的输出如下所示：
<?xml version="1.0" encoding="utf-8"?>
<People groupName="Group1">
<people>
<Person name="Roger" age="37" />
<Person name="Alice" age="27" />
<Person name="Cindy" age="17" />
</people>
</People>
也可以通过 TypeTraits 类和部分模板规范启用任何 3-rd 方类/结构支持 - 以类似于 CString 或 int 的方式定义您自己的 TypeTraitsT 类 - 请参见示例代码
https://github.com/tapika/TestCppReflect/blob/master/TypeTraits.h#L195
此解决方案适用于 Windows / Visual Studio。可以将它移植到其他操作系统/编译器，但还没有做到这一点。（问我是否真的喜欢解决方案，我可能会帮助你）
该方案适用于一类多子类的一次序列化。
但是，如果您正在寻找序列化类部分甚至控制反射调用产生的功能的机制，您可以查看以下解决方案：
https://github.com/tapika/cppscriptcore/tree/master/SolutionProjectModel
更详细的信息可以从 youtube 视频中找到：
C++ 运行时类型反射 https://youtu.be/TN8tJijkeFE
我试图更深入地解释 C++ 反射将如何工作。
示例代码将如下所示：
https://github.com/tapika/cppscriptcore/blob/master/SolutionProjectModel/testCppApp.cpp
c.General.IntDir = LR"(obj\$(ProjectName)_$(Configuration)_$(Platform)\)";
c.General.OutDir = LR"(bin\$(Configuration)_$(Platform)\)";
c.General.UseDebugLibraries = true;
c.General.LinkIncremental = true;
c.CCpp.Optimization = optimization_Disabled;
c.Linker.System.SubSystem = subsystem_Console;
c.Linker.Debugging.GenerateDebugInformation = debuginfo_true;
但是这里的每一步实际上都会导致函数调用 Using C++ properties with __declspec(property(get =, put ... ).
它以路径的形式接收有关 C++ 数据类型、C++ 属性名称和类实例指针的完整信息，并且基于该信息，您可以生成 xml、json 甚至通过 Internet 序列化该信息。
可以在此处找到此类虚拟回调函数的示例：
https://github.com/tapika/cppscriptcore/blob/master/SolutionProjectModel/VCConfiguration.cpp
见函数ReflectCopy和虚函数::OnAfterSetProperty。
但由于主题真的很高级 - 我建议先检查视频。
如果您有一些改进的想法，请随时与我联系。
于 2019-03-26T18:34:12.527 回答
3
RareCpp库使反射变得相当简单和直观——所有字段/类型信息都设计为在数组中可用或感觉像数组访问。它是为 C++17 编写的，可与 Visual Studios、g++ 和 Clang 一起使用。该库仅是标题，这意味着您只需将“Reflect.h”复制到您的项目中即可使用它。
反射结构或类需要 REFLECT 宏，您可以在其中提供要反射的类的名称和字段的名称。
class FuelTank {
public:
float capacity;
float currentLevel;
float tickMarks[2];
REFLECT(FuelTank, capacity, currentLevel, tickMarks)
};
这就是全部，不需要额外的代码来设置反射。或者，您可以提供类和字段注释，以便能够遍历超类或向字段添加额外的编译时信息（例如 Json::Ignore）。
循环遍历字段可以像...
for ( size_t i=0; i<FuelTank::Class::TotalFields; i++ )
std::cout << FuelTank::Class::Fields[i].name << std::endl;
您可以循环访问对象实例以访问字段值（您可以读取或修改）和字段类型信息...
FuelTank::Class::ForEachField(fuelTank, [&](auto & field, auto & value) {
using Type = typename std::remove_reference<decltype(value)>::type;
std::cout << TypeToStr<Type>() << " " << field.name << ": " << value << std::endl;
});
JSON 库构建在 RandomAccessReflection 之上，它自动识别用于读取或写入的适当 JSON 输出表示，并且可以递归遍历任何反射字段，以及数组和 STL 容器。
struct MyOtherObject { int myOtherInt; REFLECT(MyOtherObject, myOtherInt) };
struct MyObject
{
int myInt;
std::string myString;
MyOtherObject myOtherObject;
std::vector<int> myIntCollection;
REFLECT(MyObject, myInt, myString, myOtherObject, myIntCollection)
};
int main()
{
MyObject myObject = {};
std::cout << "Enter MyObject:" << std::endl;
std::cin >> Json::in(myObject);
std::cout << std::endl << std::endl << "You entered:" << std::endl;
std::cout << Json::pretty(myObject);
}
上面可以这样运行...
Enter MyObject:
{
"myInt": 1337, "myString": "stringy", "myIntCollection": [2,4,6],
"myOtherObject": {
"myOtherInt": 9001
}
}
You entered:
{
"myInt": 1337,
"myString": "stringy",
"myOtherObject": {
"myOtherInt": 9001
},
"myIntCollection": [ 2, 4, 6 ]
}
也可以看看...
于 2019-12-22T20:11:49.873 回答
2
当我想用 C++ 进行反射时，我阅读了这篇文章并改进了我在那里看到的内容。对不起，没有可以。我不拥有结果......但你当然可以得到我所拥有的并从那里开始。
我目前正在研究使用inherit_linearly 的方法来简化可反射类型的定义。我实际上已经走了很远，但我还有很长的路要走。C++0x 的变化很可能在这方面有很大的帮助。
于 2010-06-14T03:59:46.553 回答
2
看起来 C++ 仍然没有这个特性。而且C++11也推迟了反射（（
搜索一些宏或自己制作。Qt 也可以帮助反射（如果可以使用的话）。
于 2011-11-24T08:23:11.547 回答
2
尽管 C++ 中不支持开箱即用的反射，但实现起来并不难。我遇到了这篇很棒的文章： http ://replicaisland.blogspot.co.il/2010/11/building-reflective-object-system-in-c.html
这篇文章非常详细地解释了如何实现一个非常简单和基本的反射系统。授予它不是最健康的解决方案，并且还有一些粗糙的边缘需要整理，但对于我的需要来说已经足够了。
底线 - 如果正确完成反射可以得到回报，并且在 C++ 中是完全可行的。
于 2013-02-02T23:19:14.290 回答
2
查看 Classdesc http://classdesc.sf.net。它以类“描述符”的形式提供反射，与任何标准 C++ 编译器一起工作（是的，它可以与 Visual Studio 和 GCC 一起工作），并且不需要源代码注释（尽管存在一些 pragma 来处理棘手的情况）。它已经开发了十多年，并在多个工业规模的项目中使用。
于 2013-04-06T07:41:51.247 回答
1
我想宣传自动内省/反思工具包“IDK”的存在。它使用类似 Qt 的元编译器，并将元信息直接添加到目标文件中。据称它易于使用。没有外部依赖。它甚至允许您自动反映 std::string，然后在脚本中使用它。请看IDK
于 2014-03-12T12:18:35.200 回答
1
C++ 中的反射非常有用，如果您需要为每个成员运行一些方法（例如：序列化、散列、比较）。我提供了通用解决方案，语法非常简单：
struct S1
{
ENUMERATE_MEMBERS(str,i);
std::string str;
int i;
};
struct S2
{
ENUMERATE_MEMBERS(s1,i2);
S1 s1;
int i2;
};
其中 ENUMERATE_MEMBERS 是一个宏，后面会介绍（UPDATE）：
假设我们为 int 和 std::string 定义了序列化函数，如下所示：
void EnumerateWith(BinaryWriter & writer, int val)
{
//store integer
writer.WriteBuffer(&val, sizeof(int));
}
void EnumerateWith(BinaryWriter & writer, std::string val)
{
//store string
writer.WriteBuffer(val.c_str(), val.size());
}
而且我们在“秘密宏”附近有通用功能；）
template<typename TWriter, typename T>
auto EnumerateWith(TWriter && writer, T && val) -> is_enumerable_t<T>
{
val.EnumerateWith(write); //method generated by ENUMERATE_MEMBERS macro
}
现在你可以写
S1 s1;
S2 s2;
//....
BinaryWriter writer("serialized.bin");
EnumerateWith(writer, s1); //this will call EnumerateWith for all members of S1
EnumerateWith(writer, s2); //this will call EnumerateWith for all members of S2 and S2::s1 (recursively)
因此，在结构定义中有 ENUMERATE_MEMBERS 宏，您可以在不触及原始类型的情况下构建序列化、比较、散列和其他东西，唯一的要求是为每个枚举器（如 BinaryWriter）为每个不可枚举的类型实现“EnumerateWith”方法. 通常你必须实现 10-20 个“简单”类型来支持你项目中的任何类型。
这个宏应该在运行时对结构创建/销毁的开销为零，并且 T.EnumerateWith() 的代码应该按需生成，这可以通过使其模板内联函数来实现，所以唯一的开销是所有的故事都是将 ENUMERATE_MEMBERS(m1,m2,m3...) 添加到每个结构中，而在任何解决方案中都必须为每个成员类型实现特定方法，所以我不认为它是开销。
更新： ENUMERATE_MEMBERS 宏有一个非常简单的实现（但是可以稍微扩展以支持从可枚举结构的继承）
#define ENUMERATE_MEMBERS(...) \
template<typename TEnumerator> inline void EnumerateWith(TEnumerator & enumerator) const { EnumerateWithHelper(enumerator, __VA_ARGS__ ); }\
template<typename TEnumerator> inline void EnumerateWith(TEnumerator & enumerator) { EnumerateWithHelper(enumerator, __VA_ARGS__); }
// EnumerateWithHelper
template<typename TEnumerator, typename ...T> inline void EnumerateWithHelper(TEnumerator & enumerator, T &...v)
{
int x[] = { (EnumerateWith(enumerator, v), 1)... };
}
// Generic EnumerateWith
template<typename TEnumerator, typename T>
auto EnumerateWith(TEnumerator & enumerator, T & val) -> std::void_t<decltype(val.EnumerateWith(enumerator))>
{
val.EnumerateWith(enumerator);
}
对于这 15 行代码，您不需要任何 3rd 方库；）
于 2016-11-07T23:37:00.900 回答
1
您可以使用Boost::Hana 库中的BOOST_HANA_DEFINE_STRUCT为结构实现很酷的静态反射功能。
Hana 用途广泛，不仅适用于您想到的用例，而且适用于许多模板元编程。
于 2019-09-27T08:51:30.133 回答
0
如果你声明一个指向这样的函数的指针：
int (*func)(int a, int b);
您可以像这样将内存中的位置分配给该功能（需要libdl和dlopen）
#include <dlfcn.h>
int main(void)
{
void *handle;
char *func_name = "bla_bla_bla";
handle = dlopen("foo.so", RTLD_LAZY);
*(void **)(&func) = dlsym(handle, func_name);
return func(1,2);
}
要使用间接加载本地符号，您可以dlopen在调用二进制文件 ( argv[0]) 上使用。
对此（除了 、 和 ）的唯一要求dlopen()是libdl知道dlfcn.h函数的参数和类型。
于 2019-03-03T20:30:59.003 回答