C/C++：有什么方法可以获得反射枚举吗？

Question

我已经多次遇到这种情况了......

 enum Fruit {
  Apple,
  Banana,
  Pear,
  Tomato
 };

现在我有 Fruit f; // Banana 我想从 f 转到字符串 "Banana";或者我有 string s = "Banana" ，然后我想转到 Banana // enum value or int。

到目前为止我一直在这样做......假设枚举位于 Fruit.h 中：

// Fruit.cpp
const char *Fruits[] = {
 "Apple",
 "Banana",
 "Pear",
 "Tomato",
 NULL
};

显然这是一个混乱的解决方案。如果开发人员在标题中添加了新的水果，并且没有在 Fruits[] 中添加新的条目（不能怪他，它们必须位于两个不同的文件中！），应用程序就会繁荣起来。

有没有一种简单的方法可以做我想做的事情，所有内容都在一个文件中？预处理器黑客，外星魔法，任何东西..

PS：这与“针对所有内容”的反射相反，在编译器中实现起来非常简单。看到这个问题有多常见（至少对我来说），我真的不敢相信没有反射枚举 Fruit.. 即使在 C++0x 中也没有。

PS2：我使用的是C++，但我也将这个问题标记为C，因为C也有同样的问题。如果您的解决方案仅包含 C++ 内容，那对我来说没问题。

Answer 1

这需要在外部文件中定义水果。
这将是 fruit.cpp 的内容：

#define FRUIT(name) name
enum Fruit {
#include "fruit-defs.h"
NUM_FRUITS
};
#undef FRUIT
#define FRUIT(name) #name
const char *Fruits [] = {
#include "fruit-defs.h"
NULL
};
#undef FRUIT

这将是 fruit-defs.h：

FRUIT(Banana),
FRUIT(Apple),
FRUIT(Pear),
FRUIT(Tomato),

只要值从 0 开始并且连续，它就可以工作......

更新：如果您需要非连续值，请将此解决方案与 Richard Pennington 使用 C99 的解决方案混合。即，类似：

// This would be in fruit-defs.h
FRUIT(Banana, 7)
...
// This one for the enum
#define FRUIT(name, number) name = number
....
// This one for the char *[]
#define FRUIT(name, number) [number] = #name

Answer 2

我发现的一种 c99 方法有助于减少错误：

enum Fruit {
  APPLE,
  BANANA
};
const char* Fruits[] = {
 [APPLE] = "APPLE",
 [BANANA] = "BANANA"
};

您可以添加枚举，即使在中间，也不会破坏旧的定义。当然，您仍然可以为您忘记的值获取 NULL 字符串。

Answer 3

我过去做过的一个技巧是添加一个额外的枚举，然后执行编译时断言（例如 Boost 的）以确保两者保持同步：

enum Fruit {
    APPLE,
    BANANA,

    // MUST BE LAST ENUM
    LAST_FRUIT
};

const char *FruitNames[] =
{
    "Apple",
    "Banana",
};

BOOST_STATIC_ASSERT((sizeof(FruitNames) / sizeof(*FruitNames)) == LAST_FRUIT);

这至少可以防止有人忘记添加到枚举和名称数组中，并让他们知道一旦他们尝试编译。

Answer 4

对宏解决方案的一条评论 - 您不需要为枚举器提供单独的文件。只需使用另一个宏：（

#define FRUITs \ 
    FRUIT(Banana), \ 
    FRUIT(Apple), \ 
    FRUIT(Pear), \ 
    FRUIT(Tomato)

不过，我可能会省略逗号，并根据需要将它们合并到 FRUIT 宏中。）

Answer 5

还有Better Enums，这是一个需要C+的head-only库（文件） +11 并根据 BSD 软件许可证获得许可。官方说明：

C+ 的反射编译时枚举：Better Enums 是一个单一的轻量级头文件，可让您的编译器生成反射枚举类型。

这是来自官方网站的代码示例：

#include <enum.h>

BETTER_ENUM(Channel, int, Red = 1, Green, Blue)

Channel     c = Channel::_from_string("Red");
const char  *s = c._to_string();

size_t      n = Channel::_size();
for (Channel c : Channel::_values()) {
    run_some_function(c);
}

switch (c) {
    case Channel::Red:    // ...
    case Channel::Green:  // ...
    case Channel::Blue:   // ...
}

Channel     c = Channel::_from_integral(3);

constexpr Channel c =
    Channel::_from_string("Blue");

它看起来非常有前途，尽管我还没有测试过。此外，还有大量用于 C++ 的（自定义）反射库。我希望类似 Better Enums 的东西迟早会成为标准模板库 (STL)（或至少是 Boost）的一部分。

Answer 6

如果你做了这样的事怎么办？

enum Fruit {
  Apple,
  Banana,
  NumFruits
};

const char *Fruits[NumFruits] = {
 "Apple",
 "Banana",
};

然后，如果您向 Fruit 枚举添加一个新条目，编译器应该抱怨数组的初始值设定项中没有足够的条目，因此您将被迫向数组添加一个条目。

因此它可以防止数组大小错误，但不能帮助您确保字符串正确。

Answer 7

看一下 Metaresc 库 https://github.com/alexanderchuranov/Metaresc

它提供了类型的接口还将生成该类型的元数据的声明。基于元数据，您可以轻松地序列化/反序列化任何复杂性的对象。开箱即用，您可以序列化/反序列化 XML、JSON、YAML、XDR、类 Lisp 表示法、C-init 表示法。

这是一个简单的例子：

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

#include "metaresc.h"

TYPEDEF_ENUM (fruit_t,
              Apple,
              Banana,
              Pear,
              Tomato,
              );

int main (int argc, char * argv[])
{
  mr_td_t * tdp = mr_get_td_by_name ("fruit_t");

  if (tdp)
    {
      int i, count = tdp->param.enum_param.enums_size / sizeof (tdp->param.enum_param.enums[0]);
      for (i = 0; i < count; ++i)
        {
          mr_ed_t * edp = tdp->param.enum_param.enums[i];
          MR_PRINT ("[", edp->value._unsigned,  "] = ", edp->name.str, "\n");
        }        
    }
  return (EXIT_SUCCESS);
}

这个程序将输出

$ ./enum
[0] = Apple
[1] = Banana
[2] = Pear
[3] = Tomato

Library Works Fine forlatest gcc and clang。

Answer 8

可以为它创建一个类结构：

class Fruit { 
   int value; char const * name ; 
   protected:
   Fruit( int v, char const * n ) : value(v), name(n) {}
   public:
   int asInt() const { return value ; }
   char const * cstr() { return name ; } 
} ;
#define MAKE_FRUIT_ELEMENT( x, v ) class x : public Fruit { x() : Fruit( v, #x ) {} }

// Then somewhere:
MAKE_FRUIT_ELEMENT(Apple, 1);
MAKE_FRUIT_ELEMENT(Banana, 2);
MAKE_FRUIT_ELEMENT(Pear, 3);

然后你可以有一个接受 Fruit 的函数，它甚至会更加类型安全。

void foo( Fruit f ) {
  std::cout << f.cstr() << std::endl;
  switch (f.asInt()) { /* do whatever * } ;
}

它的大小比枚举大 2 倍。但很可能这并不重要。

Answer 9

正如回答该问题的其他人所表明的那样，仅使用 C 预处理器并没有真正干净（“DRY”）的方法来完成此操作。问题是您需要定义一个枚举大小的数组，其中包含与每个枚举值对应的字符串，而 C 预处理器不够智能，无法做到这一点。我所做的是创建一个类似这样的文本文件：

%status ok
%meaning
The routine completed its work successfully.
%

%status eof_reading_content
%meaning

The routine encountered the end of the input before it expected
to. 

%

Here %'s mark delimiters.

然后，一个 Perl 脚本（其工作部分如下所示）

sub get_statuses
{
    my ($base_name, $prefix) = @_;
    my @statuses;
    my $status_txt_file = "$base_name.txt";
    my $status_text = file_slurp ($status_txt_file);
    while ($status_text =~ 
       m/
        \%status\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\n
        \%meaning\s*(.*?)\s*\n\%\s*\n
        /gxs) {
    my ($code, $meaning) = ($1, $2);
    $code = $prefix."_$code";
    $meaning =~ s/\s+/ /g;
    push @statuses, [$code, $meaning];
    }
    return @statuses;
}

读取此文件并写入一个头文件：

typedef enum kinopiko_status {
    kinopiko_status_ok,
    kinopiko_status_eof_reading_content,

和一个 C 文件：

/* Generated by ./kinopiko-status.pl at 2009-11-09 23:45. */
#include "kinopiko-status.h"
const char * kinopiko_status_strings[26] = {
"The routine completed its work successfully.",
"The routine encountered the end of the input before it expected to. ",

使用顶部的输入文件。它还通过对输入行进行计数来计算出数字 26。 （实际上有 26 种可能的状态。）

然后使用 make 自动构建状态字符串文件。

Answer 10

总的来说，我不喜欢宏观解决方案，尽管我承认很难避免它们。

就我个人而言，我选择了一个自定义类来包装我的枚举。目标是提供比传统枚举更多的功能（例如迭代）。

在幕后，我使用 std::map 将枚举映射到其 std::string 对应项。然后我可以使用它来迭代枚举并“漂亮地打印”我的枚举或从文件中读取的字符串初始化它。

当然，问题在于定义，因为我必须首先声明枚举，然后映射它......但这就是您使用它们所付出的代价。

另外，我然后不使用真正的枚举，而是使用指向映射（在幕后）的 const_iterator 来表示枚举值（end 表示无效值）。