I did something like what you're after once, and while it's possible to get some level of reflection and access to higher-level features, the maintenance headache might not be worth it. My system was used to keep the UI classes completely separated from the business logic through delegation akin to Objective-C's concept of message passing and forwarding. The way to do it is to create some base class that is capable of mapping symbols (I used a string pool but you could do it with enums if you prefer speed and compile-time error handling over total flexibility) to function pointers (actually not pure function pointers, but something similar to what Boost has with Boost.Function--which I didn't have access to at the time). You can do the same thing for your member variables as long as you have some common base class capable of representing any value. The entire system was an unabashed ripoff of Key-Value Coding and Delegation, with a few side effects that were perhaps worth the sheer amount of time necessary to get every class that used the system to match all of its methods and members up with legal calls: 1) Any class could call any method on any other class without having to include headers or write fake base classes so the interface could be predefined for the compiler; and 2) The getters and setters of the member variables were easy to make thread-safe because changing or accessing their values was always done through 2 methods in the base class of all objects.

It also led to the possibility of doing some really weird things that otherwise aren't easy in C++. For example I could create an Array object that contained arbitrary items of any type, including itself, and create new arrays dynamically by passing a message to all array items and collecting the return values (similar to map in Lisp). Another was the implementation of key-value observing, whereby I was able to set up the UI to respond immediately to changes in the members of backend classes instead of constantly polling the data or unnecessarily redrawing the display.

也许您更感兴趣的是，您还可以转储为类定义的所有方法和成员，而且是字符串形式。

该系统的缺点可能会让您望而却步:添加所有消息和键值非常繁琐;它比没有反射要慢;你会讨厌看到boost::static_pointer_cast和boost::dynamic_pointer_cast遍布你的代码库;强类型系统的局限性仍然存在，您实际上只是将它们隐藏了一些，所以它不那么明显。字符串中的错别字也不是一个有趣或容易发现的惊喜。

As to how to implement something like this: just use shared and weak pointers to some common base (mine was very imaginatively called "Object") and derive for all the types you want to use. I'd recommend installing Boost.Function instead of doing it the way I did, which was with some custom crap and a ton of ugly macros to wrap the function pointer calls. Since everything is mapped, inspecting objects is just a matter of iterating through all of the keys. Since my classes were essentially as close to a direct ripoff of Cocoa as possible using only C++, if you want something like that then I'd suggest using the Cocoa documentation as a blueprint.

在我的c++生涯中，我知道的两个类似反射的解决方案是:

1)使用RTTI，如果你能够从一个“对象”基类派生所有的类，它将为你提供一个引导来构建类似反射的行为。该类可以提供一些方法，如GetMethod, GetBaseClass等。至于这些方法是如何工作的，你需要手动添加一些宏来装饰你的类型，这些宏在幕后创建类型的元数据，为GetMethods等提供答案。

2)如果你可以访问编译器对象，另一个选择是使用DIA SDK。如果我没记错的话，这允许您打开pdbs，其中应该包含c++类型的元数据。也许足够做你想做的事了。例如，本页展示了如何获取类的所有基类型。

这两种解决方案都有点难看!没有什么比c++更能让你欣赏c#的奢华了。

祝你好运。

你想用反射做什么? 可以使用Boost类型特征和typeof库作为编译时反射的有限形式。也就是说，您可以检查和修改传递给模板的类型的基本属性。

您需要查看您正在尝试做什么，以及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的模板魔法，可以在运行时(读取配置文件时)将其转换为一系列方法调用，因此相当高效。我不建议你这样做，除非你真的需要，但是，当你这样做的时候，你可以做一些非常酷的事情。

反射本质上是关于编译器决定在运行时代码可以查询的代码中留下哪些足迹。c++以不为不用的东西付费而闻名;因为大多数人不使用/不想要反射，c++编译器通过不记录任何东西来避免成本。

因此，c++不提供反射，并且像其他答案所指出的那样，作为一般规则，自己“模拟”它并不容易。

在“其他技术”下，如果没有带有反射的语言，可以使用一个可以在编译时提取所需信息的工具。

我们的DMS软件再造工具包是通过显式语言定义参数化的通用编译器技术。它有语言定义C, c++， Java, COBOL, PHP，…

对于C、c++、Java和COBOL版本，它提供了对解析树和符号表信息的完整访问。符号表信息包括您可能希望从“反射”中获得的数据类型。如果您的目标是枚举一组字段或方法，并对它们做一些事情，DMS可以用于根据符号表中的内容以任意方式转换代码。

如果你正在寻找相对简单的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定义使用类名+字段名+偏移量-来标识特定字段位于内存中的哪个位置。我已经尽可能地学习。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类和部分模板规范来启用任何第三方类/结构支持-以类似于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;

但是这里的每一步实际上都会导致函数调用 使用c++属性__declspec(property(get =， put…)．

它以路径的形式接收有关c++数据类型、c++属性名和类实例指针的全部信息，并根据这些信息生成xml、json，甚至在互联网上序列化这些信息。

这样的虚拟回调函数的例子可以在这里找到:

https://github.com/tapika/cppscriptcore/blob/master/SolutionProjectModel/VCConfiguration.cpp

参见函数ReflectCopy和虚函数::OnAfterSetProperty。

但是因为这个话题很高级，我建议先看视频。

如果您有一些改进的想法，请随时与我联系。