我希望能够内省一个C ++类的名称，内容（即成员及其类型）等。我在这里说的是原生C ++，而不是托管C ++，它有反射。我意识到C ++使用RTTI提供一些有限的信息。哪些额外的库（或其他技术）可以提供这些信息？
答案 0 :(得分：220)
您需要做的是让预处理器生成有关字段的反射数据。此数据可以存储为嵌套类。
首先，为了使它在预处理器中更容易和更清晰，我们将使用类型化表达式。类型化表达式只是将类型放在括号中的表达式。因此，不是写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
瞧，我们刚刚用100行代码在C ++中实现了反射。
答案 1 :(得分：97)
游泳有两种reflection。
template-tricks的C ++可以实现这种功能。使用boost::type_traits进行许多操作（例如检查类型是否为整数）。要检查成员函数是否存在，请使用Is it possible to write a template to check for a function's existence?。要检查是否存在某种嵌套类型，请使用plain SFINAE。 如果您正在寻找实现方法1），比如查看一个类有多少方法，或者喜欢获取类id的字符串表示，那么我担心没有标准的C ++方法。你必须使用
C ++的设计考虑了速度。如果你想要高级别的检查，比如C＃或Java，那我恐怕不得不告诉你没有办法没有办法。
答案 2 :(得分：55)
我会喜欢小马，但是小马不是免费的。 :-P
http://en.wikibooks.org/wiki/C%2B%2B_Programming/RTTI就是你要得到的。您正在考虑的反思 - 在运行时可用的完全描述性元数据 - 默认情况下对C ++不存在。
答案 3 :(得分：37)
C ++不存在RTTI。
这是完全错误的。实际上，术语“RTTI”是由C ++标准创造的。另一方面，RTTI在实现反射方面并没有走得太远。
答案 4 :(得分：37)
信息确实存在 - 但不是您需要的格式，并且仅在您导出类时。这适用于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之间进行流式传输等等非常有用，并且不需要从特定的基类派生。如果有足够的需求，我们可以将它敲出来以便释放。
答案 5 :(得分：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的模板魔术，这会在运行时（当读取配置文件时）被转换为一系列方法调用，因此它非常有效。除非你真的需要，我不建议这样做，但是，当你这样做时，你可以做一些非常酷的事情。
答案 6 :(得分：13)
你想用反射做什么？
您可以使用Boost type traits和typeof库作为编译时反射的有限形式。也就是说，您可以检查和修改传递给模板的类型的基本属性。
答案 7 :(得分：13)
我建议使用Qt。
有开源许可证和商业许可证。
答案 8 :(得分：12)
编辑：CAMP不再维护;有两把叉子可供选择：
CAMP是MIT许可的库（以前称为LGPL），它为C ++语言添加了反射。它不需要编译中的特定预处理步骤，但必须手动进行绑定。
当前的Tegesoft库使用Boost，但还有a fork使用C ++ 11 不再需要Boost 。
答案 9 :(得分：10)
我做了类似于你曾经做过的事情，虽然可以获得一定程度的反思和访问更高级别的功能，但维护上的头痛可能不值得。我的系统用于通过委托将UI类与业务逻辑完全分离，类似于Objective-C的消息传递和转发概念。这样做的方法是创建一些能够映射符号的基类（我使用字符串池但你可以使用枚举，如果你更喜欢速度和编译时错误处理而不是总灵活性）来实现函数指针（实际上不是纯函数指针，但类似于Boost与Boost.Function的相似之处 - 我当时没有访问权限。只要您有一些能够表示任何值的公共基类，您就可以对成员变量执行相同的操作。整个系统是一个毫不掩饰的密钥值编码和委派的冲突，有一些副作用可能值得花费足够的时间来使每个使用该系统的类匹配其所有方法和成员与合法调用：1）任何类都可以在任何其他类上调用任何方法，而不必包含头文件或编写伪基类，因此可以为编译器预定义接口; 2）成员变量的getter和setter很容易实现线程安全，因为更改或访问它们的值总是通过所有对象的基类中的2个方法来完成。
它还有可能做一些非常奇怪的事情，否则在C ++中不容易。例如，我可以创建一个包含任意类型的任意项（包括其自身）的Array对象，并通过将消息传递给所有数组项并收集返回值（类似于Lisp中的map）来动态创建新数组。另一个是键值观察的实现，我可以设置UI来立即响应后端类成员的变化，而不是不断地轮询数据或不必要地重新绘制显示。
您可能更感兴趣的是，您还可以转储为类定义的所有方法和成员，并且不会减少字符串形式。
系统的缺点可能会阻止您打扰：添加所有消息和键值非常繁琐;它比没有任何反射慢;你会厌恶在你的代码库中看到boost::static_pointer_cast和boost::dynamic_pointer_cast充满激情;强类型系统的局限性仍然存在，你真的只是隐藏它们，所以它不那么明显。你的琴弦中的错字也不是一种有趣或容易发现的惊喜。
关于如何实现这样的事情：只使用共享和弱指针到一些公共基础（我的想象力非常被称为“对象”）并派生出你想要使用的所有类型。我建议安装Boost.Function而不是像我那样做，这是一些自定义的垃圾和大量丑陋的宏来包装函数指针调用。由于所有内容都已映射，因此检查对象只需迭代所有键即可。由于我的类基本上只使用C ++就可以直接使用Cocoa，如果你想要这样的东西，那么我建议使用Cocoa文档作为蓝图。
答案 10 :(得分：9)
答案 11 :(得分：9)
我在C ++时代所知道的两种类似反射的解决方案是：
1）如果能够从“对象”基类派生所有类，则使用RTTI，它将为您提供构建类似反射的行为的引导程序。该类可以提供一些方法，如GetMethod，GetBaseClass等。至于这些方法如何工作，您需要手动添加一些宏来装饰您的类型，在幕后创建类型的元数据，以提供GetMethods的答案等。
2）如果您有权访问编译器对象，则另一个选项是使用DIA SDK。如果我没记错的话，这可以让你打开pdbs，它应该包含C ++类型的元数据。它可能足以满足您的需求。 This page显示了如何获取类的所有基类型。
这两种解决方案虽然有点难看！没有什么比C ++更能让你欣赏C＃的奢侈品了。
祝你好运。
答案 12 :(得分：7)
答案 13 :(得分：7)
开箱即用的C ++不支持反射。这很令人难过，因为它使防御性测试成为一种痛苦。
有几种做反思的方法：
第一个链接看起来最有希望（使用mod's clang），第二个链接讨论了许多技术，第三个是使用gcc的不同方法：
现在有一个C ++反射工作组。请参阅C ++ 14 @ CERN的新闻：
编辑13/08/17： 自原始帖子以来，反思已经有了许多潜在的进步。以下提供了更多细节以及对各种技术和状态的讨论：
然而，在不久的将来，C ++中的标准化反射方法看起来并不乐观，除非社区对支持C ++中的反射有更多的兴趣。
以下详细介绍了基于上次C ++标准会议反馈的当前状态：
编辑13/12/2017
反思看起来正朝着C ++ 20或更多可能是TSR迈进。然而，运动很慢。
编辑15/09/2018
已将TS草案发送给国家机构进行投票。
答案 14 :(得分：6)
我想你可能会发现Dominic Filion的文章“在C ++中使用模板反射”。它在Game Programming Gems 5的1.4节中。不幸的是，我没有我的副本，但寻找它，因为我认为它解释了你的要求。
答案 15 :(得分：6)
这个问题现在有点旧了（不知道为什么我今天仍然会遇到旧问题）但我正在考虑引入编译时反思的BOOST_FUSION_ADAPT_STRUCT。
由你来决定将它映射到运行时反射当然，它不会太容易，但它可以在这个方向上，而它不会反过来：）
我真的认为封装BOOST_FUSION_ADAPT_STRUCT的宏可以生成获取运行时行为的必要方法。
答案 16 :(得分：4)
反思主要是关于编译器决定留下什么作为运行时代码可以查询的代码中的脚印。 C ++以不付你不使用的东西而闻名;因为大多数人不使用/想要反射，C ++编译器通过不记录任何来避免成本。
因此，C ++不提供反射，并且像其他答案所指出的那样，自己“模拟”它并不容易。
在“其他技术”下，如果您没有带反射的语言， 会获得一个可以在编译时提取所需信息的工具。
我们的DMS Software Reengineering Toolkit是通过显式语言定义参数化的通用编译器技术。它有C，C ++，Java，COBOL，PHP等的语言定义。
对于C，C ++，Java和COBOL版本，它提供对解析树和符号表信息的完全访问。该符号表信息包括您可能想要从“反射”获得的数据类型。如果您的目标是枚举一些字段或方法，并使用它们做，可以使用DMS根据您在符号表中以任意方式找到的内容来转换代码。
答案 17 :(得分：4)
Ponder是一个C ++反射库，用于回答这个问题。我考虑了这些选项，并决定自己制作，因为我找不到一个勾选我所有盒子的选项。
尽管这个问题有很好的答案，但我不想使用大量的宏，或者依赖Boost。 Boost是一个很棒的库，但有许多小的定制C ++ 0x项目更简单，编译时间更短。能够在外部装饰类也有一些优点，比如包装一个不支持C ++ 11的C ++库。它是CAMP的分支，使用C ++ 11，不再需要Boost 。
答案 18 :(得分：3)
您可以在此处找到另一个图书馆：http://www.garret.ru/cppreflection/docs/reflect.html 它支持两种方式：从调试信息中获取类型信息，并让程序员提供此信息。
我也对我的项目的反思很感兴趣并找到了这个库，我还没有尝试过，但尝试了这个人的其他工具，我喜欢他们的工作方式： - ）
答案 19 :(得分：3)
查看Classdesc http://classdesc.sf.net。它以类“描述符”的形式提供反射，适用于任何标准C ++编译器（是的，它已知可以与Visual Studio以及GCC一起使用），并且不需要源代码注释（尽管存在一些编译指示来处理棘手的情况）。它已经开发了十多年，并在许多工业规模项目中使用。
答案 20 :(得分：2)
看起来C ++仍然没有这个功能。 并且 C++11 也推迟了反思（（
搜索一些宏或自己创建。 Qt也可以帮助反射（如果可以使用）。
答案 21 :(得分：2)
我想宣传自动内省/反射工具包“IDK”的存在。它使用像Qt这样的元编译器，并将元信息直接添加到目标文件中。它声称易于使用。没有外部依赖。它甚至允许您自动反映std :: string，然后在脚本中使用它。请查看IDK
答案 22 :(得分：2)
即使在c ++中不支持开箱即用的反射，也不难实现。 我遇到过这篇很棒的文章： http://replicaisland.blogspot.co.il/2010/11/building-reflective-object-system-in-c.html
文章详细解释了如何实现一个非常简单和基本的反射系统。授予它不是最健康的解决方案，并且还有一些粗略的边缘需要整理，但是对于我的需求来说已经足够了。
底线 - 如果正确完成，反射可以得到回报，并且在c ++中完全可行。
答案 23 :(得分：2)
尝试查看此项目http://www.garret.ru/cppreflection/docs/reflect.html 添加反射到C ++。它将元数据添加到您可以使用的类中。
答案 24 :(得分：2)
当我想要用C ++进行反思时，我读了this article并根据我在那里看到的内容进行了改进。对不起，没法。我不拥有结果......但你当然可以得到我所拥有的并从那里开始。
我正在研究，当我感觉到这种情况时，使用inherit_linearly来更容易地定义可反射类型的方法。我实际上已经相当远了，但我还有很长的路要走。 C ++ 0x的变化很可能在这方面有很多帮助。
答案 25 :(得分：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是一个宏，稍后将对此进行描述（更新）：
假设我们已经为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宏，您可以构建序列化，比较，散列和其他内容而无需触及原始类型，唯一的要求是为每个类型实现“EnumerateWith”方法，这是不可枚举的，每个枚举器（像BinaryWriter）。通常，您必须实现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行代码，您不需要任何第三方库;）
答案 26 :(得分：1)
在C ++ 20中，您获得了expansion statements，它允许您迭代聚合类型：
struct my_type {
double data;
std::string another_data;
int last_data;
};
auto object = my_type{};
for...(auto& member : object) {
using member_type = std::remove_cvref_t<decltype(member)>;
member = get_data<member_type>();
}
答案 27 :(得分：1)
如果您正在寻找相对简单的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 );
}
REFLECTABLE定义将类名+字段名与offsetof一起使用-标识特定字段位于内存中的哪个位置。我尝试了尽可能多的.NET术语，但是C ++和C＃是不同的，所以不是1对1。整个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方类/结构支持-以类似于CString或int的方式定义自己的TypeTraitsT类-请参见示例代码
https://github.com/tapika/TestCppReflect/blob/master/TypeTraits.h#L195
此解决方案适用于Windows / Visual Studio。可以将其移植到其他OS /编译器，但还没有完成。 （如果您真的喜欢解决方案，请问我，我也许可以为您提供帮助）
此解决方案适用于具有多个子类的一类的一枪序列化。
但是，如果您正在寻找序列化类部分的机制，或者甚至控制反射调用产生的功能，则可以查看以下解决方案：
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;
但是这里的每个步骤实际上都会导致函数调用
将C ++属性与__declspec(property(get =, put ... )一起使用。
以路径的形式接收有关C ++数据类型，C ++属性名称和类实例指针的完整信息，并基于该信息，您可以生成xml，json，甚至可以通过互联网序列化该信息。
此类虚拟回调函数的示例可在此处找到：
https://github.com/tapika/cppscriptcore/blob/master/SolutionProjectModel/VCConfiguration.cpp
请参见功能ReflectCopy和虚拟功能::OnAfterSetProperty。
但是由于主题确实很高级-我建议先检查视频。
如果您有一些改进的想法，请随时与我联系。
答案 28 :(得分：1)
您可以使用Boost :: Hana库中的BOOST_HANA_DEFINE_STRUCT为结构实现很酷的静态反射功能。
Hana用途广泛，不仅适用于您考虑的用例，而且适用于许多模板元编程。
答案 29 :(得分：0)
Root Reflex项目对此有所支持。
答案 30 :(得分：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除外）是知道函数的参数和类型。
答案 31 :(得分：0)
Random Access Reflection库使反射变得相当容易和直观-所有字段/类型信息都设计为在数组中可用或感觉像对数组的访问。它是为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： ：忽略）。
遍历字段可以很简单...
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 Library建立在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, (Reflected) 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 ]
}
另请参阅...
答案 32 :(得分：-1)
C ++缺乏内置反射是现代C ++不用于Web开发（缺少ORM和其他框架）的唯一原因
答案 33 :(得分：-4)
一种简单的方法是使用dynamic_cast<>()运算符，当分配给错误的类型时，返回NULL，这样您就可以轻松地向上转换为基本的具体类，检查指针的值，如果它不是NULL，完成了转换，你得到了对象的类型。
但这只是一个简单的解决方案，它只提供对象的类型，你不能问它有什么方法，比如Java。如果您需要高级解决方案，可以选择一些框架。