C++11 - 在编译时获取所有类变量并在没有 Boost 的情况下为它们调用方法

Question

我知道，在 C++ 中，没有反射。但是，我需要在编译时迭代变量并为它们生成代码。

我的是这样的:

class Foo {
   int x;
   double y;

   Foo() {
     Register(x, "x");
     Register(y, "y");
   }

   template <typename T>
   void Register(T val, const std::string & key){
      //do something with val and key
   }
}

但是，我想为每个变量自动调用Register。有时，它们可能有很多，很容易忘记注册某些东西或在 key 中输入错误(理想情况下，key 应该与变量名相同)。

我想到了类似CREATE_AND_REGISTER(x, "x") 的宏，但我不知道是否可行。我见过一些基于 Boost 的解决方案，但我只需要普通的 C+11/14。

Answer 1

我不认为有可能做真正想做的事(“无反射”)但是......

I have thought of something like CREATE_AND_REGISTER(x, "x") macro, but I dont know if it is possible

我认为 c-macros 是提炼出来的邪恶但是...如果你真的想要并且如果你接受 int x 和 float y 被包装在结构中......我提出以下宏

#define DEFandREGIS(type, name, def)            \
                                                \
   struct bar_##name                            \
    {                                           \
      type var;                                 \
                                                \
      bar_##name (type val, foo * t) : var{val} \
       { t->regis(var, #name); }                \
    };                                          \
                                                \
   bar_##name b##name{def, this};

接收类型(int, float, ...)，名称(x, y, ...) 和默认值

所以(如果默认值对你来说足够了)你可以定义 foo 如下

struct foo
 {
   DEFandREGIS(int, x, 1)
   DEFandREGIS(float, y, 2.2)

   template <typename T>
   void regis (T val, std::string const & key)
    { std::cout << "regis(" << val << ", \"" << key << "\")" << std::endl; }
 };

然后，定义一个 foo 变量，您将得到打印

 regis(1, "x")
 regis(2.2, "y")

如果你想要一个foo构造函数可以创建具有不同(非默认值)的x和y，你可以确认默认构造函数(如果你愿意的话)并创建另一个构造函数，如下所示

foo () = default;

foo (int x0, float y0) : bx{x0, this}, by{y0, this}
 { }

如果您的Register() 方法(regis()，在我的示例中)可以是static 方法，则不需要this 指针在 bar##x 中，您可以稍微简化示例。

下面是一个完整的工作示例

#include <iostream>

#define DEFandREGIS(type, name, def)            \
                                                \
   struct bar_##name                            \
    {                                           \
      type var;                                 \
                                                \
      bar_##name (type val, foo * t) : var{val} \
       { t->regis(var, #name); }                \
    };                                          \
                                                \
   bar_##name b##name{def, this};

struct foo
 {
   DEFandREGIS(int, x, 1)
   DEFandREGIS(float, y, 2.2f)

   foo () = default;

   foo (int x0, float y0) : bx{x0, this}, by{y0, this}
    { }

   template <typename T>
   void regis (T val, std::string const & key)
    { std::cout << "regis(" << val << ", \"" << key << "\")" << std::endl; }
 };

int main()
 {
   foo a;
   foo b{3, 4.4f};
 }