与所有其他类似问题相反，该问题与使用新的C ++功能有关。

阅读许多答案后，我尚未找到任何答案：

使用C ++ 11，C ++ 14或C ++ 17新功能的优雅方式
或在Boost中随时可用的东西
其他一些计划用于C ++ 20的东西

例

一个例子通常比冗长的解释更好。
您可以在Coliru上编译并运行此代码段。
^{（另一个以前的示例也可用）}

#include <map>
#include <iostream>

struct MyClass
{
    enum class MyEnum : char {
        AAA = -8,
        BBB = '8',
        CCC = AAA + BBB
    };
};

// Replace magic() by some faster compile-time generated code
// (you're allowed to replace the return type with std::string
// if that's easier for you)
const char* magic (MyClass::MyEnum e)
{
    const std::map<MyClass::MyEnum,const char*> MyEnumStrings {
        { MyClass::MyEnum::AAA, "MyClass::MyEnum::AAA" },
        { MyClass::MyEnum::BBB, "MyClass::MyEnum::BBB" },
        { MyClass::MyEnum::CCC, "MyClass::MyEnum::CCC" }
    };
    auto   it  = MyEnumStrings.find(e);
    return it == MyEnumStrings.end() ? "Out of range" : it->second;
}

int main()
{
   std::cout << magic(MyClass::MyEnum::AAA) <<'\n';
   std::cout << magic(MyClass::MyEnum::BBB) <<'\n';
   std::cout << magic(MyClass::MyEnum::CCC) <<'\n';
}

约束条件

请不要重复其他答案或基本链接。
请避免基于宏的膨胀答案，或尝试尽可能减少#define开销。
请不要手动enum-> string映射。

很高兴有

支持enum值从零开始
支持负的enum值
支持零碎的enum价值
支持class enum（C ++ 11）
支持class enum : <type>任何允许的<type>（C ++ 11）
编译时（而非运行时）转换为字符串，
或者至少在运行时快速执行（例如，std::map这不是一个好主意...）
constexpr （C ++ 11，然后在C ++ 14/17/20中放松）
noexcept （C ++ 11）
C ++ 17 / C ++ 20友好代码段

一种可能的想法是使用C ++编译器功能在编译时使用基于variadic template class和constexpr函数的元编程技巧来生成C ++代码。

— 寡头
source

4

（也许是话题性的）看一下与Qt相关的博客。woboq.com/blog/reflection-in-cpp-and-qt-moc.html。描述了使用C ++反射（建议的标准）替换Qt的moc（元对象编译器）的可能性。

— ibre5041 2015年

10

N4113：std::enumerator::identifier_v<MyEnum, MyEnum::AAA>

— ecatmur'3

1

我个人通过实现一个小的预处理器实用程序库解决了这个问题，该程序库使我可以遍历可变参数宏参数并在所有参数上执行功能。我将枚举值作为宏参数传递，并通过预处理器自动生成枚举和字符串数组。您可能也可以使用Boost Preprocessor进行此操作。

— 罗密欧

2

一切都必须用C ++解决吗？自动为字符串表示生成代码非常容易，只需几行代码。

— Karoly Horvath'3

2

“请不要提供基于C宏观答案如果可能的话”，除非你愿意等待C ++ 17也几乎没有什么可用的，这是不是说的那样糟糕来声明枚举DEC_ENUM(enumname, (a,b,c,(d,b),(e,42)))，除非你有maintaint的生成宏...，恕我直言，将这种情况放入语言中只是替代一种更强大的模板/宏混合功能的另一种方法。我们不应将所有这些有用的宏用例添加到该语言中，仅是为了说宏不再有用。

— PlasmaHH 2015年

42

Magic Enum仅标头库为C ++ 17提供了枚举（到字符串，字符串，迭代）的静态反射。

#include <magic_enum.hpp>

enum Color { RED = 2, BLUE = 4, GREEN = 8 };

Color color = Color::RED;
auto color_name = magic_enum::enum_name(color);
// color_name -> "RED"

std::string color_name{"GREEN"};
auto color = magic_enum::enum_cast<Color>(color_name)
if (color.has_value()) {
  // color.value() -> Color::GREEN
};

有关更多示例，请查看主存储库https://github.com/Neargye/magic_enum。

缺点在哪里？

该库使用特定于编译器的黑客（基于__PRETTY_FUNCTION__/ __FUNCSIG__），可在Clang> = 5，MSVC> = 15.3和GCC> = 9上工作。

枚举值必须在范围内[MAGIC_ENUM_RANGE_MIN, MAGIC_ENUM_RANGE_MAX]。

默认情况下MAGIC_ENUM_RANGE_MIN = -128，MAGIC_ENUM_RANGE_MAX = 128。
如果默认情况下所有枚举类型都需要另一个范围，请重新定义宏MAGIC_ENUM_RANGE_MIN和MAGIC_ENUM_RANGE_MAX。
MAGIC_ENUM_RANGE_MIN必须小于或等于0并且必须大于INT16_MIN。
MAGIC_ENUM_RANGE_MAX必须大于0且必须小于INT16_MAX。

如果需要用于特定枚举类型的其他范围，请为必要的枚举类型添加特殊化enum_range。

#include <magic_enum.hpp>

enum number { one = 100, two = 200, three = 300 };

namespace magic_enum {
template <>
  struct enum_range<number> {
    static constexpr int min = 100;
    static constexpr int max = 300;
};
}

— Neargye
source

为什么范围限制？是要限制某种递归深度，还是由于某种编译时线性搜索？

— Emile Cormier

这真太了不起了。谢谢！如果编译器足够聪明，可以仅一次评估constexpr std :: array，那么它甚至可能是有效的。非常非常棒。

— iestyn

87

_{（Better_enums库的方法）}

在当前的C ++中有一种方法可以枚举字符串，如下所示：

ENUM(Channel, char, Red = 1, Green, Blue)

// "Same as":
// enum class Channel : char { Red = 1, Green, Blue };

用法：

Channel     c = Channel::_from_string("Green");  // Channel::Green (2)
c._to_string();                                  // string "Green"

for (Channel c : Channel::_values())
    std::cout << c << std::endl;

// And so on...

可以进行所有操作constexpr。您还可以实现@ecatmur的答案中提到的C ++ 17反射建议。

只有一个宏。我相信这是最小的可能，因为预处理程序字符串化（#）是在当前C ++中将令牌转换为字符串的唯一方法。
该宏非常简单-常量声明（包括初始化程序）被粘贴到内置的enum声明中。这意味着它们具有与内置枚举相同的语法和含义。
重复被消除。
由于，实现至少在C ++ 11中是最自然和有用的constexpr。也可以使其与C ++ 98 +一起使用__VA_ARGS__。绝对是现代C ++。

宏的定义有些涉及，所以我以几种方式回答。

这个答案的大部分是我认为适合StackOverflow的空间限制的实现。
在长篇教程中，还有一个CodeProject文章描述了实现的基础。[ 我应该把它移到这里吗？我认为SO答案太多了。
有一个功能齐全的库“更好的枚举”，可在单个头文件中实现该宏。它还实现了N4428类型属性查询，这是C ++ 17反射建议N4113的最新版本。因此，至少对于通过此宏声明的枚举，现在可以在C ++ 11 / C ++ 14中具有建议的C ++ 17枚举反射。

将答案扩展到库的功能很简单-这里没有“重要”的地方。但是，这非常繁琐，并且存在编译器可移植性问题。

免责声明：我是CodeProject文章和库的作者。

您可以在Wandbox中在线尝试此答案中的代码，库和N4428在线实现。库文档还包含有关如何将其用作N4428的概述，它解释了该提案的枚举部分。

说明

下面的代码实现枚举和字符串之间的转换。但是，它也可以扩展为做其他事情，例如迭代。此答案将枚举包装在struct。您也可以struct在枚举旁边生成特征。

该策略是生成如下内容：

struct Channel {
    enum _enum : char { __VA_ARGS__ };
    constexpr static const Channel          _values[] = { __VA_ARGS__ };
    constexpr static const char * const     _names[] = { #__VA_ARGS__ };

    static const char* _to_string(Channel v) { /* easy */ }
    constexpr static Channel _from_string(const char *s) { /* easy */ }
};

问题是：

我们最终将得到类似于{Red = 1, Green, Blue}values数组的初始化程序。这不是有效的C ++，因为Red它不是可分配的表达式。这可以通过将每个常量转换为T具有赋值运算符的类型来解决，但会删除赋值：{(T)Red = 1, (T)Green, (T)Blue}。
同样，我们最终将{"Red = 1", "Green", "Blue"}作为names数组的初始化程序。我们将需要修剪掉" = 1"。我不知道在编译时执行此操作的好方法，因此我们将其推迟到运行时。结果，_to_string将不会是constexpr，但_from_string仍然可能是constexpr，因为与未修剪的字符串进行比较时，我们可以将空格和等号视为终止符。
以上两个都需要一个“映射”宏，该宏可以将另一个宏应用于中的每个元素__VA_ARGS__。这是很标准的。该答案包括一个可处理多达8个元素的简单版本。
如果要真正实现宏的自包含，则无需声明需要单独定义的静态数据。实际上，这意味着阵列需要特殊处理。有两种可能的解决方案：（constexpr或仅是const）在名称空间范围内的数组，或在非constexpr静态内联函数中的常规数组。此答案中的代码适用于C ++ 11，并采用了前一种方法。CodeProject文章适用于C ++ 98，并采用了后者。

码

#include <cstddef>      // For size_t.
#include <cstring>      // For strcspn, strncpy.
#include <stdexcept>    // For runtime_error.



// A "typical" mapping macro. MAP(macro, a, b, c, ...) expands to
// macro(a) macro(b) macro(c) ...
// The helper macro COUNT(a, b, c, ...) expands to the number of
// arguments, and IDENTITY(x) is needed to control the order of
// expansion of __VA_ARGS__ on Visual C++ compilers.
#define MAP(macro, ...) \
    IDENTITY( \
        APPLY(CHOOSE_MAP_START, COUNT(__VA_ARGS__)) \
            (macro, __VA_ARGS__))

#define CHOOSE_MAP_START(count) MAP ## count

#define APPLY(macro, ...) IDENTITY(macro(__VA_ARGS__))

#define IDENTITY(x) x

#define MAP1(m, x)      m(x)
#define MAP2(m, x, ...) m(x) IDENTITY(MAP1(m, __VA_ARGS__))
#define MAP3(m, x, ...) m(x) IDENTITY(MAP2(m, __VA_ARGS__))
#define MAP4(m, x, ...) m(x) IDENTITY(MAP3(m, __VA_ARGS__))
#define MAP5(m, x, ...) m(x) IDENTITY(MAP4(m, __VA_ARGS__))
#define MAP6(m, x, ...) m(x) IDENTITY(MAP5(m, __VA_ARGS__))
#define MAP7(m, x, ...) m(x) IDENTITY(MAP6(m, __VA_ARGS__))
#define MAP8(m, x, ...) m(x) IDENTITY(MAP7(m, __VA_ARGS__))

#define EVALUATE_COUNT(_1, _2, _3, _4, _5, _6, _7, _8, count, ...) \
    count

#define COUNT(...) \
    IDENTITY(EVALUATE_COUNT(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1))



// The type "T" mentioned above that drops assignment operations.
template <typename U>
struct ignore_assign {
    constexpr explicit ignore_assign(U value) : _value(value) { }
    constexpr operator U() const { return _value; }

    constexpr const ignore_assign& operator =(int dummy) const
        { return *this; }

    U   _value;
};



// Prepends "(ignore_assign<_underlying>)" to each argument.
#define IGNORE_ASSIGN_SINGLE(e) (ignore_assign<_underlying>)e,
#define IGNORE_ASSIGN(...) \
    IDENTITY(MAP(IGNORE_ASSIGN_SINGLE, __VA_ARGS__))

// Stringizes each argument.
#define STRINGIZE_SINGLE(e) #e,
#define STRINGIZE(...) IDENTITY(MAP(STRINGIZE_SINGLE, __VA_ARGS__))



// Some helpers needed for _from_string.
constexpr const char    terminators[] = " =\t\r\n";

// The size of terminators includes the implicit '\0'.
constexpr bool is_terminator(char c, size_t index = 0)
{
    return
        index >= sizeof(terminators) ? false :
        c == terminators[index] ? true :
        is_terminator(c, index + 1);
}

constexpr bool matches_untrimmed(const char *untrimmed, const char *s,
                                 size_t index = 0)
{
    return
        is_terminator(untrimmed[index]) ? s[index] == '\0' :
        s[index] != untrimmed[index] ? false :
        matches_untrimmed(untrimmed, s, index + 1);
}



// The macro proper.
//
// There are several "simplifications" in this implementation, for the
// sake of brevity. First, we have only one viable option for declaring
// constexpr arrays: at namespace scope. This probably should be done
// two namespaces deep: one namespace that is likely to be unique for
// our little enum "library", then inside it a namespace whose name is
// based on the name of the enum to avoid collisions with other enums.
// I am using only one level of nesting.
//
// Declaring constexpr arrays inside the struct is not viable because
// they will need out-of-line definitions, which will result in
// duplicate symbols when linking. This can be solved with weak
// symbols, but that is compiler- and system-specific. It is not
// possible to declare constexpr arrays as static variables in
// constexpr functions due to the restrictions on such functions.
//
// Note that this prevents the use of this macro anywhere except at
// namespace scope. Ironically, the C++98 version of this, which can
// declare static arrays inside static member functions, is actually
// more flexible in this regard. It is shown in the CodeProject
// article.
//
// Second, for compilation performance reasons, it is best to separate
// the macro into a "parametric" portion, and the portion that depends
// on knowing __VA_ARGS__, and factor the former out into a template.
//
// Third, this code uses a default parameter in _from_string that may
// be better not exposed in the public interface.

#define ENUM(EnumName, Underlying, ...)                               \
namespace data_ ## EnumName {                                         \
    using _underlying = Underlying;                                   \
    enum { __VA_ARGS__ };                                             \
                                                                      \
    constexpr const size_t           _size =                          \
        IDENTITY(COUNT(__VA_ARGS__));                                 \
                                                                      \
    constexpr const _underlying      _values[] =                      \
        { IDENTITY(IGNORE_ASSIGN(__VA_ARGS__)) };                     \
                                                                      \
    constexpr const char * const     _raw_names[] =                   \
        { IDENTITY(STRINGIZE(__VA_ARGS__)) };                         \
}                                                                     \
                                                                      \
struct EnumName {                                                     \
    using _underlying = Underlying;                                   \
    enum _enum : _underlying { __VA_ARGS__ };                         \
                                                                      \
    const char * _to_string() const                                   \
    {                                                                 \
        for (size_t index = 0; index < data_ ## EnumName::_size;      \
             ++index) {                                               \
                                                                      \
            if (data_ ## EnumName::_values[index] == _value)          \
                return _trimmed_names()[index];                       \
        }                                                             \
                                                                      \
        throw std::runtime_error("invalid value");                    \
    }                                                                 \
                                                                      \
    constexpr static EnumName _from_string(const char *s,             \
                                           size_t index = 0)          \
    {                                                                 \
        return                                                        \
            index >= data_ ## EnumName::_size ?                       \
                    throw std::runtime_error("invalid identifier") :  \
            matches_untrimmed(                                        \
                data_ ## EnumName::_raw_names[index], s) ?            \
                    (EnumName)(_enum)data_ ## EnumName::_values[      \
                                                            index] :  \
            _from_string(s, index + 1);                               \
    }                                                                 \
                                                                      \
    EnumName() = delete;                                              \
    constexpr EnumName(_enum value) : _value(value) { }               \
    constexpr operator _enum() const { return (_enum)_value; }        \
                                                                      \
  private:                                                            \
    _underlying     _value;                                           \
                                                                      \
    static const char * const * _trimmed_names()                      \
    {                                                                 \
        static char     *the_names[data_ ## EnumName::_size];         \
        static bool     initialized = false;                          \
                                                                      \
        if (!initialized) {                                           \
            for (size_t index = 0; index < data_ ## EnumName::_size;  \
                 ++index) {                                           \
                                                                      \
                size_t  length =                                      \
                    std::strcspn(data_ ## EnumName::_raw_names[index],\
                                 terminators);                        \
                                                                      \
                the_names[index] = new char[length + 1];              \
                                                                      \
                std::strncpy(the_names[index],                        \
                             data_ ## EnumName::_raw_names[index],    \
                             length);                                 \
                the_names[index][length] = '\0';                      \
            }                                                         \
                                                                      \
            initialized = true;                                       \
        }                                                             \
                                                                      \
        return the_names;                                             \
    }                                                                 \
};

和

// The code above was a "header file". This is a program that uses it.
#include <iostream>
#include "the_file_above.h"

ENUM(Channel, char, Red = 1, Green, Blue)

constexpr Channel   channel = Channel::_from_string("Red");

int main()
{
    std::cout << channel._to_string() << std::endl;

    switch (channel) {
        case Channel::Red:   return 0;
        case Channel::Green: return 1;
        case Channel::Blue:  return 2;
    }
}

static_assert(sizeof(Channel) == sizeof(char), "");

Red如您所料，上面的程序会打印。有一定程度的类型安全性，因为如果不初始化它就无法创建枚举，并且从中删除其中一种情况switch将导致编译器发出警告（取决于编译器和标志）。另外，请注意"Red"在编译期间已将其转换为枚举。

— 前子
source

Heya @mrhthepie，很抱歉您的编辑被拒绝了。我刚刚看到了有关它的电子邮件。我将把它纳入答案–感谢您的错误修正！

— antron 2016年

这很棒。如果我想要一个枚举位，这也行得通吗？就像我想要一个BitFlags枚举一样，每个枚举都1U移位了多少？

— user3240688 '16

1

_trimmed_names()您在此处发布的代码中似乎存在内存泄漏（new char[length + 1]但您未将其设置initialized为true）。我错过了什么吗？我在您的github代码中没有看到相同的问题。

— user3240688 '16

1

它设置为true，但是在if分支之外（最初由@mrhthepie捕获的内存泄漏）。应该将其移入...编辑中。感谢您仔细查看此代码和GH代码。

— antron

1

to_string可以string_view从不需要空终止的C ++ 17 返回a ，并成为constexpr。

— Yakk-Adam Nevraumont'9

74

对于~~C ++ 17~~ C ++ 20，您将对反思研究小组（SG7）的工作感兴趣。有一系列平行的论文，涵盖措辞（P0194）和基本原理，设计与演变（P0385）。（链接解析为每个系列的最新论文。）

从P0194r2（2016-10-15）开始，语法将使用建议的reflexpr关键字：

meta::get_base_name_v<
  meta::get_element_m<
    meta::get_enumerators_m<reflexpr(MyEnum)>,
    0>
  >

例如（改编自Matus Choclik的clang reflexpr分支）：

#include <reflexpr>
#include <iostream>

enum MyEnum { AAA = 1, BBB, CCC = 99 };

int main()
{
  auto name_of_MyEnum_0 = 
    std::meta::get_base_name_v<
      std::meta::get_element_m<
        std::meta::get_enumerators_m<reflexpr(MyEnum)>,
        0>
    >;

  // prints "AAA"
  std::cout << name_of_MyEnum_0 << std::endl;
}

静态反射未能使它成为C ++ 17（相反，成为了2016年11月在伊萨夸举行的标准会议上提出的最终草案），但有信心将其纳入C ++ 20；但是，我们有信心将其纳入C ++ 20。来自Herb Sutter的旅行报告：

特别是，反射研究小组审查了最新的合并静态反射提议，并发现它准备在下一次会议上加入主要的Evolution组，以开始考虑针对TS或下一标准的统一静态反射提议。

— 恶魔
source

2

@antron对不起，您的编辑被拒绝了；如果我及时看到的话，我会批准的。我没看过N4428，所以谢谢您的注意。

— 2015年

3

没问题，感谢您将其合并。我有点奇怪为什么它被拒绝了。我看到“没有使其更加精确”的样板，但今天显然更准确。

— antron 2015年

1

谢谢:-)我分割了最后一个示例，以避免使用水平滚动条。可惜该值MyEnum::AAA不能作为第二个参数传递std::meta::get_enumerators_m：-/

— olibre

1

这样的概念上简单的任务需要3个级别的嵌套模板参数，这一事实是过度设计的。我敢肯定有具体的技术原因。但这并不意味着最终结果是用户友好的。我爱C ++，代码对我来说很有意义。但是我每天与之合作的其他程序员中有90％会因为这样的代码而避开C ++。我没有看到任何更简单的内置解决方案而感到失望。

— void.pointer

2

这似乎在标准列入即将到来的反思TS的目前的估计是C ++ 23： herbsutter.com/2018/04/02/...

— 蒂姆·雷伊

25

这类似于Yuri Finkelstein；但不需要提升。我使用的是地图，因此您可以将任何值分配给枚举，并采用任何顺序。

枚举类声明为：

DECLARE_ENUM_WITH_TYPE(TestEnumClass, int32_t, ZERO = 0x00, TWO = 0x02, ONE = 0x01, THREE = 0x03, FOUR);

以下代码将自动创建枚举类和重载：

'+''+ ='for std :: string
流的“ <<”
'〜'只是转换为字符串（任何一元运算符都可以，但是我个人并不喜欢这样做）
'*'获取枚举数

无需增强功能，提供所有必需的功能。

码：

#include <algorithm>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>

#define STRING_REMOVE_CHAR(str, ch) str.erase(std::remove(str.begin(), str.end(), ch), str.end())

std::vector<std::string> splitString(std::string str, char sep = ',') {
    std::vector<std::string> vecString;
    std::string item;

    std::stringstream stringStream(str);

    while (std::getline(stringStream, item, sep))
    {
        vecString.push_back(item);
    }

    return vecString;
}

#define DECLARE_ENUM_WITH_TYPE(E, T, ...)                                                                     \
    enum class E : T                                                                                          \
    {                                                                                                         \
        __VA_ARGS__                                                                                           \
    };                                                                                                        \
    std::map<T, std::string> E##MapName(generateEnumMap<T>(#__VA_ARGS__));                                    \
    std::ostream &operator<<(std::ostream &os, E enumTmp)                                                     \
    {                                                                                                         \
        os << E##MapName[static_cast<T>(enumTmp)];                                                            \
        return os;                                                                                            \
    }                                                                                                         \
    size_t operator*(E enumTmp) { (void) enumTmp; return E##MapName.size(); }                                 \
    std::string operator~(E enumTmp) { return E##MapName[static_cast<T>(enumTmp)]; }                          \
    std::string operator+(std::string &&str, E enumTmp) { return str + E##MapName[static_cast<T>(enumTmp)]; } \
    std::string operator+(E enumTmp, std::string &&str) { return E##MapName[static_cast<T>(enumTmp)] + str; } \
    std::string &operator+=(std::string &str, E enumTmp)                                                      \
    {                                                                                                         \
        str += E##MapName[static_cast<T>(enumTmp)];                                                           \
        return str;                                                                                           \
    }                                                                                                         \
    E operator++(E &enumTmp)                                                                                  \
    {                                                                                                         \
        auto iter = E##MapName.find(static_cast<T>(enumTmp));                                                 \
        if (iter == E##MapName.end() || std::next(iter) == E##MapName.end())                                  \
            iter = E##MapName.begin();                                                                        \
        else                                                                                                  \
        {                                                                                                     \
            ++iter;                                                                                           \
        }                                                                                                     \
        enumTmp = static_cast<E>(iter->first);                                                                \
        return enumTmp;                                                                                       \
    }                                                                                                         \
    bool valid##E(T value) { return (E##MapName.find(value) != E##MapName.end()); }

#define DECLARE_ENUM(E, ...) DECLARE_ENUM_WITH_TYPE(E, int32_t, __VA_ARGS__)
template <typename T>
std::map<T, std::string> generateEnumMap(std::string strMap)
{
    STRING_REMOVE_CHAR(strMap, ' ');
    STRING_REMOVE_CHAR(strMap, '(');

    std::vector<std::string> enumTokens(splitString(strMap));
    std::map<T, std::string> retMap;
    T inxMap;

    inxMap = 0;
    for (auto iter = enumTokens.begin(); iter != enumTokens.end(); ++iter)
    {
        // Token: [EnumName | EnumName=EnumValue]
        std::string enumName;
        T enumValue;
        if (iter->find('=') == std::string::npos)
        {
            enumName = *iter;
        }
        else
        {
            std::vector<std::string> enumNameValue(splitString(*iter, '='));
            enumName = enumNameValue[0];
            //inxMap = static_cast<T>(enumNameValue[1]);
            if (std::is_unsigned<T>::value)
            {
                inxMap = static_cast<T>(std::stoull(enumNameValue[1], 0, 0));
            }
            else
            {
                inxMap = static_cast<T>(std::stoll(enumNameValue[1], 0, 0));
            }
        }
        retMap[inxMap++] = enumName;
    }

    return retMap;
}

例：

DECLARE_ENUM_WITH_TYPE(TestEnumClass, int32_t, ZERO = 0x00, TWO = 0x02, ONE = 0x01, THREE = 0x03, FOUR);

int main(void) {
    TestEnumClass first, second;
    first = TestEnumClass::FOUR;
    second = TestEnumClass::TWO;

    std::cout << first << "(" << static_cast<uint32_t>(first) << ")" << std::endl; // FOUR(4)

    std::string strOne;
    strOne = ~first;
    std::cout << strOne << std::endl; // FOUR

    std::string strTwo;
    strTwo = ("Enum-" + second) + (TestEnumClass::THREE + "-test");
    std::cout << strTwo << std::endl; // Enum-TWOTHREE-test

    std::string strThree("TestEnumClass: ");
    strThree += second;
    std::cout << strThree << std::endl; // TestEnumClass: TWO
    std::cout << "Enum count=" << *first << std::endl;
}

You can run the code here

— 达尼洛·拉莫斯（Danilo Ramos）
source

1

我们可以在此宏定义中使用换行符吗？

— einpoklum

1

我添加了用于*获取枚举数的重载...我希望您不要介意:-)

— Peter VARGA，

1

此实现有任何理由使用std::map（O（log（n））索引）而不是std::unordered_map（O（1）索引）吗？

— 谭河

1

另外，我认为应该对方法进行标记，inline以便您可以像正常一样在头文件中声明枚举，而不会从链接程序中得到“多重定义”错误。（尽管不确定这是否是最干净/最好的解决方案）

— 河（River Tam

1

（对垃圾邮件表示抱歉，但我今天似乎无法编辑评论）在头文件中还有其他问题。映射（E##MapName）需要移动到也可以访问该枚举的编译单元。我已经创建了一个解决方案，但是它不是很干净，我必须获得共享的许可。就目前而言，我只是在说，如果没有支持头文件中使用情况的其他附加功能，则以内联方式标记方法是没有意义的。

— 谭河

19

早在2011年，我花了一个周末对基于宏的解决方案进行微调，结果却从未使用过。

我当前的过程是启动Vim，将枚举器复制到一个空的开关主体中，启动一个新的宏，将第一个枚举器转换为case语句，将光标移至下一行的开头，停止宏并生成剩余的case通过在其他枚举器上运行宏来执行语句。

Vim宏比C ++宏更有趣。

现实生活中的例子：

enum class EtherType : uint16_t
{
    ARP   = 0x0806,
    IPv4  = 0x0800,
    VLAN  = 0x8100,
    IPv6  = 0x86DD
};

我将创建这个：

std::ostream& operator<< (std::ostream& os, EtherType ethertype)
{
    switch (ethertype)
    {
        case EtherType::ARP : return os << "ARP" ;
        case EtherType::IPv4: return os << "IPv4";
        case EtherType::VLAN: return os << "VLAN";
        case EtherType::IPv6: return os << "IPv6";
        // omit default case to trigger compiler warning for missing cases
    };
    return os << static_cast<std::uint16_t>(ethertype);
}

这就是我的方法。

不过，对枚举字符串化的本地支持会更好。我非常有兴趣看到C ++ 17中的反射工作组的结果。

@sehe在评论中发布了另一种方法。

— 堆叠弯曲
source

1

我正是这样做的。虽然我通常使用环绕vim和块选择沿着路

— sehe

@sehe有趣。我应该看一下“环绕声”，因为我目前需要许多击键的方法。

— StackedCrokeed

这是全部内容，没有宏（除非.计数）：i.imgur.com/gY4ZhBE.gif

— 2015年

1

动画gif很可爱，但是很难说出它的开始和结束时间以及到达的距离。……实际上，这不是很可爱，而是令人分心。我说杀死它。

— einpoklum

vim中的这种块选择方法很不错，但为什么不简单地使用诸如此类:'<,'>s/ *\(.*\)=.*/case EtherType::\1: return os << "\1";/呢？

— 罗斯兰

14

我不知道您是否喜欢这种解决方案，对此解决方案我不太满意，但这是一种C ++ 14友好的方法，因为它使用模板变量并滥用模板专业化：

enum class MyEnum : std::uint_fast8_t {
   AAA,
   BBB,
   CCC,
};

template<MyEnum> const char MyEnumName[] = "Invalid MyEnum value";
template<> const char MyEnumName<MyEnum::AAA>[] = "AAA";
template<> const char MyEnumName<MyEnum::BBB>[] = "BBB";
template<> const char MyEnumName<MyEnum::CCC>[] = "CCC";

int main()
{
    // Prints "AAA"
    std::cout << MyEnumName<MyEnum::AAA> << '\n';
    // Prints "Invalid MyEnum value"
    std::cout << MyEnumName<static_cast<MyEnum>(0x12345678)> << '\n';
    // Well... in fact it prints "Invalid MyEnum value" for any value
    // different of MyEnum::AAA, MyEnum::BBB or MyEnum::CCC.

    return 0;
}

这种方法最糟糕的是，要维持它很痛苦，但是要维持其他一些类似的方法也很痛苦，不是吗？

关于此方法的要点：

使用可变模板（C ++ 14功能）
通过模板专用化，我们可以“检测”何时使用了无效值（但是我不确定这是否可能有用）。
看起来很整洁。
名称查找在编译时完成。

Live example

编辑

Misterious user673679你是对的; C ++ 14变量模板方法无法处理运行时情况，忘记它是我的错:(

但是我们仍然可以使用一些现代的C ++功能和变量模板以及可变参数模板技巧来实现从枚举值到字符串的运行时转换……它和其他方法一样麻烦，但仍然值得一提。

让我们开始使用模板别名来缩短对枚举到字符串映射的访问：

// enum_map contains pairs of enum value and value string for each enum
// this shortcut allows us to use enum_map<whatever>.
template <typename ENUM>
using enum_map = std::map<ENUM, const std::string>;

// This variable template will create a map for each enum type which is
// instantiated with.
template <typename ENUM>
enum_map<ENUM> enum_values{};

然后，可变参数模板的技巧：

template <typename ENUM>
void initialize() {}

template <typename ENUM, typename ... args>
void initialize(const ENUM value, const char *name, args ... tail)
{
    enum_values<ENUM>.emplace(value, name);
    initialize<ENUM>(tail ...);
}

这里的“ 最佳技巧 ”是在映射中使用变量模板，该模板包含每个枚举条目的值和名称。该映射在每个翻译单元中都相同，并且在每个地方都具有相同的名称，因此，如果我们initialize像下面这样调用函数，它将非常简单明了：

initialize
(
    MyEnum::AAA, "AAA",
    MyEnum::BBB, "BBB",
    MyEnum::CCC, "CCC"
);

我们为每个MyEnum条目分配名称，并且可以在运行时使用：

std::cout << enum_values<MyEnum>[MyEnum::AAA] << '\n';

但是可以通过SFINAE和重载<<运算符进行改进：

template<typename ENUM, class = typename std::enable_if<std::is_enum<ENUM>::value>::type>
std::ostream &operator <<(std::ostream &o, const ENUM value)
{
    static const std::string Unknown{std::string{typeid(ENUM).name()} + " unknown value"};
    auto found = enum_values<ENUM>.find(value);

    return o << (found == enum_values<ENUM>.end() ? Unknown : found->second);
}

现在正确operator <<了，我们可以这样使用枚举：

std::cout << MyEnum::AAA << '\n';

这也很麻烦维护并且可以改进，但是希望您能理解。

Live example

— 纸鸟大师
source

这看起来很整洁（是否可以不定义非专业变量？）。也许我缺少了一些东西，尽管我根本看不到它如何处理运行时情况。

— user673679 2015年

@Paula_plus_plus：您不应该只使用an std::array而不是笨拙的地图吗？仅对于以... ^，2 ^ 10值开头的枚举才是首选。也许更多。

— einpoklum

如果我们可以在运行时确保enum有多少个元素，那么@einpoklum将会很棒。不幸的是，我们不能。映射的重点仅在于将名称与值相关联，这std::map是有好处的。

— PaperBirdMaster

@Paula_plus_plus：您已经在调用一个initialize()函数，其参数数量是枚举值的数量，因此您知道编译时的值数量。仅在运行时才知道您要打印的特定值。同样，即使您不知道该数字，在几乎所有实际情况下，std :: vector也会比std :: map更快。

— einpoklum

@einpoklum确实是一个很好的观点，我会考虑的，谢谢！唯一让我担心的是，std::array它不是键值容器，因此缺少查找方法。无论如何，我会考虑一下。

— PaperBirdMaster

7

如果你enum看起来像

enum MyEnum
{
  AAA = -8,
  BBB = '8',
  CCC = AAA + BBB
};

您可以将的内容移动enum到新文件：

AAA = -8,
BBB = '8',
CCC = AAA + BBB

然后，值可以被宏包围：

// default definition
#ifned ITEM(X,Y)
#define ITEM(X,Y)
#endif

// Items list
ITEM(AAA,-8)
ITEM(BBB,'8')
ITEM(CCC,AAA+BBB)

// clean up
#undef ITEM

下一步可能会enum再次包含以下项目：

enum MyEnum
{
  #define ITEM(X,Y) X=Y,
  #include "enum_definition_file"
};

最后，您可以生成关于以下内容的实用程序函数enum：

std::string ToString(MyEnum value)
{
  switch( value )
  {
    #define ITEM(X,Y) case X: return #X;
    #include "enum_definition_file"
  }

  return "";
}

MyEnum FromString(std::string const& value)
{
  static std::map<std::string,MyEnum> converter
  {
    #define ITEM(X,Y) { #X, X },
    #include "enum_definition_file"
  };

  auto it = converter.find(value);
  if( it != converter.end() )
    return it->second;
  else
    throw std::runtime_error("Value is missing");
}

该解决方案可以应用于较早的C ++标准，并且不使用现代C ++元素，但是可以用于生成大量代码，而无需付出过多的精力和维护。

— 冒犯
source

3

不需要单独的文件。本质上是x宏。

— HolyBlackCat

@HolyBlackCat如果将解决方案拆分为一些文件，则可以将枚举值重新用于不同的目的

— eferion

我试图说的是，如果将值列表放在标头中的枚举定义旁边的单个宏中，则可以执行相同的操作。

— HolyBlackCat

@HolyBlackCat是的，我了解您，但我更喜欢此解决方案。另一方面，可以在clang源代码中找到此解决方案，所以我认为这是解决问题的好方法

— eferion

很公平。我猜这不应该被否决，因为它确实可以有一些用途。（请原谅虚拟编辑，否则系统将锁定我的投票。）

— HolyBlackCat

6

几天前我遇到了同样的问题。没有一些奇怪的宏魔术，我找不到任何C ++解决方案，所以我决定编写CMake代码生成器来生成简单的switch case语句。

用法：

enum2str_generate(
  PATH          <path to place the files in>
  CLASS_NAME    <name of the class (also prefix for the files)>
  FUNC_NAME     <name of the (static) member function>
  NAMESPACE     <the class will be inside this namespace>
  INCLUDES      <LIST of files where the enums are defined>
  ENUMS         <LIST of enums to process>
  BLACKLIST     <LIST of constants to ignore>
  USE_CONSTEXPR <whether to use constexpr or not (default: off)>
  USE_C_STRINGS <whether to use c strings instead of std::string or not (default: off)>
)

该函数搜索文件系统中的包含文件（使用include_directories命令提供的包含目录），读取它们并执行一些正则表达式来生成类和函数。

注意：constexpr暗示在C ++中是内联的，因此使用USE_CONSTEXPR选项将生成仅标头的类！

例：

./includes/ah：

enum AAA : char { A1, A2 };

typedef enum {
   VAL1          = 0,
   VAL2          = 1,
   VAL3          = 2,
   VAL_FIRST     = VAL1,    // Ignored
   VAL_LAST      = VAL3,    // Ignored
   VAL_DUPLICATE = 1,       // Ignored
   VAL_STRANGE   = VAL2 + 1 // Must be blacklisted
} BBB;

./CMakeLists.txt：

include_directories( ${PROJECT_SOURCE_DIR}/includes ...)

enum2str_generate(
   PATH       "${PROJECT_SOURCE_DIR}"
   CLASS_NAME "enum2Str"
   NAMESPACE  "abc"
   FUNC_NAME  "toStr"
   INCLUDES   "a.h" # WITHOUT directory
   ENUMS      "AAA" "BBB"
   BLACKLIST  "VAL_STRANGE")

产生：

./enum2Str.hpp：

/*!
  * \file enum2Str.hpp
  * \warning This is an automatically generated file!
  */

#ifndef ENUM2STR_HPP
#define ENUM2STR_HPP

#include <string>
#include <a.h>

namespace abc {

class enum2Str {
 public:
   static std::string toStr( AAA _var ) noexcept;
   static std::string toStr( BBB _var ) noexcept;
};

}

#endif // ENUM2STR_HPP

./enum2Str.cpp：

/*!
  * \file enum2Str.cpp
  * \warning This is an automatically generated file!
  */

#include "enum2Str.hpp"

namespace abc {

/*!
 * \brief Converts the enum AAA to a std::string
 * \param _var The enum value to convert
 * \returns _var converted to a std::string
 */
std::string enum2Str::toStr( AAA _var ) noexcept {
   switch ( _var ) {
      case A1: return "A1";
      case A2: return "A2";
      default: return "<UNKNOWN>";
   }
}

/*!
 * \brief Converts the enum BBB to a std::string
 * \param _var The enum value to convert
 * \returns _var converted to a std::string
 */
std::string enum2Str::toStr( BBB _var ) noexcept {
   switch ( _var ) {
      case VAL1: return "VAL1";
      case VAL2: return "VAL2";
      case VAL3: return "VAL3";
      default: return "<UNKNOWN>";
   }
}
}

更新：

该脚本现在还支持作用域枚举（枚举类| struct），我将其与其他一些我经常使用的脚本一起移到了单独的存储库中：https : //github.com/mensinda/cmakeBuildTools

— ense
source

哇！非常原始且创新的想法：-)我希望您有勇气升级您的生成器以提供constexpr和noexcept版本；-)我也刚刚注视着您的GitHub项目 ;-)干杯

— olibre

1

更新了生成器。这些函数现在将始终为constexpr和enum：现在支持<type>。感谢星星:)

— Mense

链接已断开... -.-

— yeoman

现在，链接已修复。

— Mense

4

只是生成您的枚举。为此目的编写一个生成器大约需要五分钟的时间。

Java和python中的生成器代码，超级容易移植到您喜欢的任何语言，包括C ++。

超级容易通过您想要的任何功能进行扩展。

输入示例：

First = 5
Second
Third = 7
Fourth
Fifth=11

生成的标头：

#include <iosfwd>

enum class Hallo
{
    First = 5,
    Second = 6,
    Third = 7,
    Fourth = 8,
    Fifth = 11
};

std::ostream & operator << (std::ostream &, const Hallo&);

生成的cpp文件

#include <ostream>

#include "Hallo.h"

std::ostream & operator << (std::ostream &out, const Hallo&value)
{
    switch(value)
    {
    case Hallo::First:
        out << "First";
        break;
    case Hallo::Second:
        out << "Second";
        break;
    case Hallo::Third:
        out << "Third";
        break;
    case Hallo::Fourth:
        out << "Fourth";
        break;
    case Hallo::Fifth:
        out << "Fifth";
        break;
    default:
        out << "<unknown>";
    }

    return out;
}

生成器以非常简洁的形式作为移植和扩展的模板。此示例代码确实试图避免覆盖任何文件，但仍然需要您自担风险。

package cppgen;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class EnumGenerator
{
    static void fail(String message)
    {
        System.err.println(message);
        System.exit(1);
    }

    static void run(String[] args)
    throws Exception
    {
        Pattern pattern = Pattern.compile("\\s*(\\w+)\\s*(?:=\\s*(\\d+))?\\s*", Pattern.UNICODE_CHARACTER_CLASS);
        Charset charset = Charset.forName("UTF8");
        String tab = "    ";

        if (args.length != 3)
        {
            fail("Required arguments: <enum name> <input file> <output dir>");
        }

        String enumName = args[0];

        File inputFile = new File(args[1]);

        if (inputFile.isFile() == false)
        {
            fail("Not a file: [" + inputFile.getCanonicalPath() + "]");
        }

        File outputDir = new File(args[2]);

        if (outputDir.isDirectory() == false)
        {
            fail("Not a directory: [" + outputDir.getCanonicalPath() + "]");
        }

        File headerFile = new File(outputDir, enumName + ".h");
        File codeFile = new File(outputDir, enumName + ".cpp");

        for (File file : new File[] { headerFile, codeFile })
        {
            if (file.exists())
            {
                fail("Will not overwrite file [" + file.getCanonicalPath() + "]");
            }
        }

        int nextValue = 0;

        Map<String, Integer> fields = new LinkedHashMap<>();

        try
        (
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile), charset));
        )
        {
            while (true)
            {
                String line = reader.readLine();

                if (line == null)
                {
                    break;
                }

                if (line.trim().length() == 0)
                {
                    continue;
                }

                Matcher matcher = pattern.matcher(line);

                if (matcher.matches() == false)
                {
                    fail("Syntax error: [" + line + "]");
                }

                String fieldName = matcher.group(1);

                if (fields.containsKey(fieldName))
                {
                    fail("Double fiend name: " + fieldName);
                }

                String valueString = matcher.group(2);

                if (valueString != null)
                {
                    int value = Integer.parseInt(valueString);

                    if (value < nextValue)
                    {
                        fail("Not a monotonous progression from " + nextValue + " to " + value + " for enum field " + fieldName);
                    }

                    nextValue = value;
                }

                fields.put(fieldName, nextValue);

                ++nextValue;
            }
        }

        try
        (
            PrintWriter headerWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(headerFile), charset));
            PrintWriter codeWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(codeFile), charset));
        )
        {
            headerWriter.println();
            headerWriter.println("#include <iosfwd>");
            headerWriter.println();
            headerWriter.println("enum class " + enumName);
            headerWriter.println('{');
            boolean first = true;
            for (Entry<String, Integer> entry : fields.entrySet())
            {
                if (first == false)
                {
                    headerWriter.println(",");
                }

                headerWriter.print(tab + entry.getKey() + " = " + entry.getValue());

                first = false;
            }
            if (first == false)
            {
                headerWriter.println();
            }
            headerWriter.println("};");
            headerWriter.println();
            headerWriter.println("std::ostream & operator << (std::ostream &, const " + enumName + "&);");
            headerWriter.println();

            codeWriter.println();
            codeWriter.println("#include <ostream>");
            codeWriter.println();
            codeWriter.println("#include \"" + enumName + ".h\"");
            codeWriter.println();
            codeWriter.println("std::ostream & operator << (std::ostream &out, const " + enumName + "&value)");
            codeWriter.println('{');
            codeWriter.println(tab + "switch(value)");
            codeWriter.println(tab + '{');
            first = true;
            for (Entry<String, Integer> entry : fields.entrySet())
            {
                codeWriter.println(tab + "case " + enumName + "::" + entry.getKey() + ':');
                codeWriter.println(tab + tab + "out << \"" + entry.getKey() + "\";");
                codeWriter.println(tab + tab + "break;");

                first = false;
            }
            codeWriter.println(tab + "default:");
            codeWriter.println(tab + tab + "out << \"<unknown>\";");
            codeWriter.println(tab + '}');
            codeWriter.println();
            codeWriter.println(tab + "return out;");
            codeWriter.println('}');
            codeWriter.println();
        }
    }

    public static void main(String[] args)
    {
        try
        {
            run(args);
        }
        catch(Exception exc)
        {
            exc.printStackTrace();
            System.exit(1);
        }
    }
}

和Python 3.5的移植版，因为相异程度足以潜在帮助

import re
import collections
import sys
import io
import os

def fail(*args):
    print(*args)
    exit(1)

pattern = re.compile(r'\s*(\w+)\s*(?:=\s*(\d+))?\s*')
tab = "    "

if len(sys.argv) != 4:
    n=0
    for arg in sys.argv:
        print("arg", n, ":", arg, " / ", sys.argv[n])
        n += 1
    fail("Required arguments: <enum name> <input file> <output dir>")

enumName = sys.argv[1]

inputFile = sys.argv[2]

if not os.path.isfile(inputFile):
    fail("Not a file: [" + os.path.abspath(inputFile) + "]")

outputDir = sys.argv[3]

if not os.path.isdir(outputDir):
    fail("Not a directory: [" + os.path.abspath(outputDir) + "]")

headerFile = os.path.join(outputDir, enumName + ".h")
codeFile = os.path.join(outputDir, enumName + ".cpp")

for file in [ headerFile, codeFile ]:
    if os.path.exists(file):
        fail("Will not overwrite file [" + os.path.abspath(file) + "]")

nextValue = 0

fields = collections.OrderedDict()

for line in open(inputFile, 'r'):
    line = line.strip()

    if len(line) == 0:
        continue

    match = pattern.match(line)

    if match == None:
        fail("Syntax error: [" + line + "]")

    fieldName = match.group(1)

    if fieldName in fields:
        fail("Double field name: " + fieldName)

    valueString = match.group(2)

    if valueString != None:
        value = int(valueString)

        if value < nextValue:
            fail("Not a monotonous progression from " + nextValue + " to " + value + " for enum field " + fieldName)

        nextValue = value

    fields[fieldName] = nextValue

    nextValue += 1

headerWriter = open(headerFile, 'w')
codeWriter = open(codeFile, 'w')

try:
    headerWriter.write("\n")
    headerWriter.write("#include <iosfwd>\n")
    headerWriter.write("\n")
    headerWriter.write("enum class " + enumName + "\n")
    headerWriter.write("{\n")
    first = True
    for fieldName, fieldValue in fields.items():
        if not first:
            headerWriter.write(",\n")

        headerWriter.write(tab + fieldName + " = " + str(fieldValue))

        first = False
    if not first:
        headerWriter.write("\n")
    headerWriter.write("};\n")
    headerWriter.write("\n")
    headerWriter.write("std::ostream & operator << (std::ostream &, const " + enumName + "&);\n")
    headerWriter.write("\n")

    codeWriter.write("\n")
    codeWriter.write("#include <ostream>\n")
    codeWriter.write("\n")
    codeWriter.write("#include \"" + enumName + ".h\"\n")
    codeWriter.write("\n")
    codeWriter.write("std::ostream & operator << (std::ostream &out, const " + enumName + "&value)\n")
    codeWriter.write("{\n")
    codeWriter.write(tab + "switch(value)\n")
    codeWriter.write(tab + "{\n")
    for fieldName in fields.keys():
        codeWriter.write(tab + "case " + enumName + "::" + fieldName + ":\n")
        codeWriter.write(tab + tab + "out << \"" + fieldName + "\";\n")
        codeWriter.write(tab + tab + "break;\n")
    codeWriter.write(tab + "default:\n")
    codeWriter.write(tab + tab + "out << \"<unknown>\";\n")
    codeWriter.write(tab + "}\n")
    codeWriter.write("\n")
    codeWriter.write(tab + "return out;\n")
    codeWriter.write("}\n")
    codeWriter.write("\n")
finally:
    headerWriter.close()
    codeWriter.close()

— 约曼
source

1

非常感谢您用两种语言共享生成器：-)但是您是否知道如何在编译时生成？例如，我们能否想象在输入数据更改时使用CMake语句转换生成器以刷新C ++生成的代码？我的梦想是迫使C ++编译器使用元编程（variadic template class和constexpr函数）在编译时生成枚举。

— olibre

Otoh，如果添加自定义cmake命令太麻烦，则可以自动化IDE或手动调用gererator，并将输出置于源代码管理中。无论如何，在源代码控制中生成代码有时是一个好主意，只要不要太多，而且人们会理解他们不应该进行手动更改，因为有时在您查看生成文件的历史记录时会很有趣正在调试一些怪异的东西，并怀疑发电机最近的更改可能破坏了某些东西:)

— yeoman

关于在编译时生成事物，在LISP中如此简单，因为语法非常简洁易用。这是因为它是动态键入的，这使它在没有太多语法的情况下即可简洁易读。与C ++中的LISP宏等效，它需要一种非常复杂的方式来描述您尝试生成的内容的AST。而且C ++的AST从来都不是好看的:(

— yeoman

直接在Make中而不是cmake，顺便说一句。只需通过find为每个.enum文件生成.h和.cpp目标，并使这些目标取决于所述的enum def，因此一旦.enum def文件更改，它们将自动重新生成。在cmake中这可能要容易得多，因为它充满了此类事物的魔力，但是我经常使用Make，ant和gradle，但对Maven，cmake和grunt的了解有限：）

— yeoman

谢谢您的回答:-)我想大多数的C ++的开发人员会明白，如果你能发电机直接在C ++代码像检测枚举enum class Hallo{ First=5, Second=6, Third=7, Fourth=8};或几行:-D你认为你可以以检测适应您的生成enum一个C ++内文件？最好的办法是仅在检测到类似的标签时生成代码/*<Generate enum to string here>*/。然后，生成器就地编写相应的C ++生成的代码（替换先前生成的代码）。^ _ ^真是个很棒的生成器吗？干杯：-)

— olibre

3

根据OP的要求，这里是基于Boost Preprosessor和Variadic Macros的丑陋宏解决方案的简化版本。

它允许一个简单的列表，例如枚举器元素的语法以及特定元素的设置值，以便

XXX_ENUM(foo,(a,b,(c,42)));

扩展到

enum foo {
    a,
    b,
    c=42
};

除了必要的功能外，还可以输出并进行一些转换。这个宏已经存在了很长时间了，我不确定它是最有效的方法还是一致的方法，但是从那以后它一直在起作用

完整的代码可以在Ideone和Coliru上看到。

它的巨大丑陋在上面；如果我知道的话，我会把它放在破坏者的后面，以保护您的眼睛，但降价促销不喜欢我。

库（合并到一个头文件中）

#include <boost/preprocessor.hpp>
#include <string>
#include <unordered_map>

namespace xxx
{

template<class T>
struct enum_cast_adl_helper { };

template<class E>
E enum_cast( const std::string& s )
{
    return do_enum_cast(s,enum_cast_adl_helper<E>());
}

template<class E>
E enum_cast( const char* cs )
{
    std::string s(cs);
    return enum_cast<E>(s);
}

} // namespace xxx

#define XXX_PP_ARG_N(                             \
          _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
         _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
         _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
         _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
         _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
         _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
         _61,_62,_63,N,...) N

#define XXX_PP_RSEQ_N()                 \
         63,62,61,60,                   \
         59,58,57,56,55,54,53,52,51,50, \
         49,48,47,46,45,44,43,42,41,40, \
         39,38,37,36,35,34,33,32,31,30, \
         29,28,27,26,25,24,23,22,21,20, \
         19,18,17,16,15,14,13,12,11,10, \
         9,8,7,6,5,4,3,2,1,0 

#define XXX_PP_NARG_(...) XXX_PP_ARG_N(__VA_ARGS__)
#define XXX_PP_NARG(...)  XXX_PP_NARG_(__VA_ARGS__,XXX_PP_RSEQ_N())
#define XXX_TUPLE_SIZE_INTERNAL(TUPLE) XXX_PP_NARG TUPLE

#define XXX_TUPLE_CHOICE(i)                            \
  BOOST_PP_APPLY(                                      \
    BOOST_PP_TUPLE_ELEM(                               \
      25, i, (                                         \
        (0), (1), (2), (3), (4), (5), (6), (7), (8),   \
        (9), (10), (11), (12), (13), (14), (15), (16), \
        (17), (18), (19), (20), (21), (22), (23), (24) \
  ) ) )

#define BOOST_PP_BOOL_00  BOOST_PP_BOOL_0
#define BOOST_PP_BOOL_01  BOOST_PP_BOOL_1
#define BOOST_PP_BOOL_02  BOOST_PP_BOOL_2
#define BOOST_PP_BOOL_03  BOOST_PP_BOOL_3
#define BOOST_PP_BOOL_04  BOOST_PP_BOOL_4
#define BOOST_PP_BOOL_05  BOOST_PP_BOOL_5
#define BOOST_PP_BOOL_06  BOOST_PP_BOOL_6
#define BOOST_PP_BOOL_07  BOOST_PP_BOOL_7
#define BOOST_PP_BOOL_08  BOOST_PP_BOOL_8
#define BOOST_PP_BOOL_09  BOOST_PP_BOOL_9
#define BOOST_PP_BOOL_010 BOOST_PP_BOOL_10
#define BOOST_PP_BOOL_011 BOOST_PP_BOOL_11
#define BOOST_PP_BOOL_012 BOOST_PP_BOOL_12
#define BOOST_PP_BOOL_013 BOOST_PP_BOOL_13
#define BOOST_PP_BOOL_014 BOOST_PP_BOOL_14
#define BOOST_PP_BOOL_015 BOOST_PP_BOOL_15
#define BOOST_PP_BOOL_016 BOOST_PP_BOOL_16
#define BOOST_PP_BOOL_017 BOOST_PP_BOOL_17
#define BOOST_PP_BOOL_018 BOOST_PP_BOOL_18
#define BOOST_PP_BOOL_019 BOOST_PP_BOOL_19
#define BOOST_PP_BOOL_020 BOOST_PP_BOOL_20
#define BOOST_PP_BOOL_021 BOOST_PP_BOOL_21
#define BOOST_PP_BOOL_022 BOOST_PP_BOOL_22
#define BOOST_PP_BOOL_023 BOOST_PP_BOOL_23
#define BOOST_PP_BOOL_024 BOOST_PP_BOOL_24
#define BOOST_PP_BOOL_025 BOOST_PP_BOOL_25
#define BOOST_PP_BOOL_026 BOOST_PP_BOOL_26
#define BOOST_PP_BOOL_027 BOOST_PP_BOOL_27
#define BOOST_PP_BOOL_028 BOOST_PP_BOOL_28
#define BOOST_PP_BOOL_029 BOOST_PP_BOOL_29
#define BOOST_PP_BOOL_030 BOOST_PP_BOOL_30
#define BOOST_PP_BOOL_031 BOOST_PP_BOOL_31
#define BOOST_PP_BOOL_032 BOOST_PP_BOOL_32
#define BOOST_PP_BOOL_033 BOOST_PP_BOOL_33
#define BOOST_PP_BOOL_034 BOOST_PP_BOOL_34
#define BOOST_PP_BOOL_035 BOOST_PP_BOOL_35
#define BOOST_PP_BOOL_036 BOOST_PP_BOOL_36
#define BOOST_PP_BOOL_037 BOOST_PP_BOOL_37
#define BOOST_PP_BOOL_038 BOOST_PP_BOOL_38
#define BOOST_PP_BOOL_039 BOOST_PP_BOOL_39
#define BOOST_PP_BOOL_040 BOOST_PP_BOOL_40
#define BOOST_PP_BOOL_041 BOOST_PP_BOOL_41
#define BOOST_PP_BOOL_042 BOOST_PP_BOOL_42
#define BOOST_PP_BOOL_043 BOOST_PP_BOOL_43
#define BOOST_PP_BOOL_044 BOOST_PP_BOOL_44
#define BOOST_PP_BOOL_045 BOOST_PP_BOOL_45
#define BOOST_PP_BOOL_046 BOOST_PP_BOOL_46
#define BOOST_PP_BOOL_047 BOOST_PP_BOOL_47
#define BOOST_PP_BOOL_048 BOOST_PP_BOOL_48
#define BOOST_PP_BOOL_049 BOOST_PP_BOOL_49
#define BOOST_PP_BOOL_050 BOOST_PP_BOOL_50
#define BOOST_PP_BOOL_051 BOOST_PP_BOOL_51
#define BOOST_PP_BOOL_052 BOOST_PP_BOOL_52
#define BOOST_PP_BOOL_053 BOOST_PP_BOOL_53
#define BOOST_PP_BOOL_054 BOOST_PP_BOOL_54
#define BOOST_PP_BOOL_055 BOOST_PP_BOOL_55
#define BOOST_PP_BOOL_056 BOOST_PP_BOOL_56
#define BOOST_PP_BOOL_057 BOOST_PP_BOOL_57
#define BOOST_PP_BOOL_058 BOOST_PP_BOOL_58
#define BOOST_PP_BOOL_059 BOOST_PP_BOOL_59
#define BOOST_PP_BOOL_060 BOOST_PP_BOOL_60
#define BOOST_PP_BOOL_061 BOOST_PP_BOOL_61
#define BOOST_PP_BOOL_062 BOOST_PP_BOOL_62
#define BOOST_PP_BOOL_063 BOOST_PP_BOOL_63

#define BOOST_PP_DEC_00  BOOST_PP_DEC_0
#define BOOST_PP_DEC_01  BOOST_PP_DEC_1
#define BOOST_PP_DEC_02  BOOST_PP_DEC_2
#define BOOST_PP_DEC_03  BOOST_PP_DEC_3
#define BOOST_PP_DEC_04  BOOST_PP_DEC_4
#define BOOST_PP_DEC_05  BOOST_PP_DEC_5
#define BOOST_PP_DEC_06  BOOST_PP_DEC_6
#define BOOST_PP_DEC_07  BOOST_PP_DEC_7
#define BOOST_PP_DEC_08  BOOST_PP_DEC_8
#define BOOST_PP_DEC_09  BOOST_PP_DEC_9
#define BOOST_PP_DEC_010 BOOST_PP_DEC_10
#define BOOST_PP_DEC_011 BOOST_PP_DEC_11
#define BOOST_PP_DEC_012 BOOST_PP_DEC_12
#define BOOST_PP_DEC_013 BOOST_PP_DEC_13
#define BOOST_PP_DEC_014 BOOST_PP_DEC_14
#define BOOST_PP_DEC_015 BOOST_PP_DEC_15
#define BOOST_PP_DEC_016 BOOST_PP_DEC_16
#define BOOST_PP_DEC_017 BOOST_PP_DEC_17
#define BOOST_PP_DEC_018 BOOST_PP_DEC_18
#define BOOST_PP_DEC_019 BOOST_PP_DEC_19
#define BOOST_PP_DEC_020 BOOST_PP_DEC_20
#define BOOST_PP_DEC_021 BOOST_PP_DEC_21
#define BOOST_PP_DEC_022 BOOST_PP_DEC_22
#define BOOST_PP_DEC_023 BOOST_PP_DEC_23
#define BOOST_PP_DEC_024 BOOST_PP_DEC_24
#define BOOST_PP_DEC_025 BOOST_PP_DEC_25
#define BOOST_PP_DEC_026 BOOST_PP_DEC_26
#define BOOST_PP_DEC_027 BOOST_PP_DEC_27
#define BOOST_PP_DEC_028 BOOST_PP_DEC_28
#define BOOST_PP_DEC_029 BOOST_PP_DEC_29
#define BOOST_PP_DEC_030 BOOST_PP_DEC_30
#define BOOST_PP_DEC_031 BOOST_PP_DEC_31
#define BOOST_PP_DEC_032 BOOST_PP_DEC_32
#define BOOST_PP_DEC_033 BOOST_PP_DEC_33
#define BOOST_PP_DEC_034 BOOST_PP_DEC_34
#define BOOST_PP_DEC_035 BOOST_PP_DEC_35
#define BOOST_PP_DEC_036 BOOST_PP_DEC_36
#define BOOST_PP_DEC_037 BOOST_PP_DEC_37
#define BOOST_PP_DEC_038 BOOST_PP_DEC_38
#define BOOST_PP_DEC_039 BOOST_PP_DEC_39
#define BOOST_PP_DEC_040 BOOST_PP_DEC_40
#define BOOST_PP_DEC_041 BOOST_PP_DEC_41
#define BOOST_PP_DEC_042 BOOST_PP_DEC_42
#define BOOST_PP_DEC_043 BOOST_PP_DEC_43
#define BOOST_PP_DEC_044 BOOST_PP_DEC_44
#define BOOST_PP_DEC_045 BOOST_PP_DEC_45
#define BOOST_PP_DEC_046 BOOST_PP_DEC_46
#define BOOST_PP_DEC_047 BOOST_PP_DEC_47
#define BOOST_PP_DEC_048 BOOST_PP_DEC_48
#define BOOST_PP_DEC_049 BOOST_PP_DEC_49
#define BOOST_PP_DEC_050 BOOST_PP_DEC_50
#define BOOST_PP_DEC_051 BOOST_PP_DEC_51
#define BOOST_PP_DEC_052 BOOST_PP_DEC_52
#define BOOST_PP_DEC_053 BOOST_PP_DEC_53
#define BOOST_PP_DEC_054 BOOST_PP_DEC_54
#define BOOST_PP_DEC_055 BOOST_PP_DEC_55
#define BOOST_PP_DEC_056 BOOST_PP_DEC_56
#define BOOST_PP_DEC_057 BOOST_PP_DEC_57
#define BOOST_PP_DEC_058 BOOST_PP_DEC_58
#define BOOST_PP_DEC_059 BOOST_PP_DEC_59
#define BOOST_PP_DEC_060 BOOST_PP_DEC_60
#define BOOST_PP_DEC_061 BOOST_PP_DEC_61
#define BOOST_PP_DEC_062 BOOST_PP_DEC_62
#define BOOST_PP_DEC_063 BOOST_PP_DEC_63

#define XXX_TO_NUMx(x) 0 ## x
#define XXX_TO_NUM(x) BOOST_PP_ADD(0,XXX_TO_NUMx(x))
#define XXX_STRINGIZEX(x) # x
#define XXX_VSTRINGIZE_SINGLE(a,b,x) XXX_STRINGIZE(x)
#define XXX_VSTRINGIZE_TUPLE(tpl) XXX_TUPLE_FOR_EACH(XXX_VSTRINGIZE_SINGLE,,tpl)
#define XXX_TUPLE_SIZE(TUPLE) XXX_TO_NUM(XXX_TUPLE_CHOICE(XXX_TUPLE_SIZE_INTERNAL(TUPLE)))
#define XXX_TUPLE_FOR_EACH(MACRO,DATA,TUPLE) BOOST_PP_LIST_FOR_EACH(MACRO,DATA,BOOST_PP_TUPLE_TO_LIST(XXX_TUPLE_SIZE(TUPLE),TUPLE))
#define XXX_STRINGIZE(x) XXX_STRINGIZEX(x)
#define XXX_VSTRINGIZE(...) XXX_VSTRINGIZE_TUPLE((__VA_ARGS__))
#define XXX_CAST_TO_VOID_ELEMENT(r,data,elem) (void)(elem);
#define XXX_CAST_TO_VOID_INTERNAL(TUPLE) XXX_TUPLE_FOR_EACH(XXX_CAST_TO_VOID_ELEMENT,,TUPLE)    
#define XXX_CAST_TO_VOID(...) XXX_CAST_TO_VOID_INTERNAL((__VA_ARGS__))
#define XXX_ENUM_EXTRACT_SP(en) BOOST_PP_TUPLE_ELEM(XXX_TUPLE_SIZE(en),0,en) = BOOST_PP_TUPLE_ELEM(XXX_TUPLE_SIZE(en),1,en)
#define XXX_ENUM_ELEMENT(r,data,elem) BOOST_PP_IF( XXX_TUPLE_SIZE(elem), XXX_ENUM_EXTRACT_SP(elem), elem) ,
#define XXX_ENUM_EXTRACT_ELEMENT(en) BOOST_PP_TUPLE_ELEM(XXX_TUPLE_SIZE(en),0,en)
#define XXX_ENUM_CASE_ELEMENT(en) BOOST_PP_IF( XXX_TUPLE_SIZE(en), XXX_ENUM_EXTRACT_ELEMENT(en), en )
#define XXX_ENUM_CASE(r,data,elem) case data :: XXX_ENUM_CASE_ELEMENT(elem) : return #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem));
#define XXX_ENUM_IFELSE(r,data,elem) else if( en == data :: XXX_ENUM_CASE_ELEMENT(elem)) { return #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)); }
#define XXX_ENUM_CASTLIST(r,data,elem) { XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)), data :: XXX_ENUM_CASE_ELEMENT(elem) },
#define XXX_ENUM_QUALIFIED_CASTLIST(r,data,elem) { #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)), data :: XXX_ENUM_CASE_ELEMENT(elem) },

#define XXX_ENUM_INTERNAL(TYPE,NAME,TUPLE)                       \
enum TYPE                                                        \
{                                                                \
   XXX_TUPLE_FOR_EACH(XXX_ENUM_ELEMENT,,TUPLE)                   \
   BOOST_PP_CAT(last_enum_,NAME)                                 \
};                                                               \
                                                                 \
inline                                                           \
const char* to_string( NAME en )                                 \
{                                                                \
   if(false)                                                     \
   {                                                             \
   }                                                             \
   XXX_TUPLE_FOR_EACH(XXX_ENUM_IFELSE,NAME,TUPLE)                \
   else if( en == NAME :: BOOST_PP_CAT(last_enum_,NAME) )        \
   {                                                             \
     return XXX_VSTRINGIZE(NAME,::,BOOST_PP_CAT(last_enum_,NAME));  \
   }                                                             \
   else                                                          \
   {                                                             \
     return "Invalid enum value specified for " # NAME;          \
   }                                                             \
}                                                                \
                                                                 \
inline                                                           \
std::ostream& operator<<( std::ostream& os, const NAME& en )     \
{                                                                \
   os << to_string(en);                                          \
   return os;                                                    \
}                                                                \
                                                                 \
inline                                                           \
NAME do_enum_cast( const std::string& s, const ::xxx::enum_cast_adl_helper<NAME>& ) \
{                                                                \
  static const std::unordered_map<std::string,NAME> map =        \
  {                                                              \
    XXX_TUPLE_FOR_EACH(XXX_ENUM_CASTLIST,NAME,TUPLE)             \
    XXX_TUPLE_FOR_EACH(XXX_ENUM_QUALIFIED_CASTLIST,NAME,TUPLE)   \
  };                                                             \
                                                                 \
  auto cit = map.find(s);                                        \
  if( cit == map.end() )                                         \
  {                                                              \
    throw std::runtime_error("Invalid value to cast to enum");   \
  }                                                              \
  return cit->second;                                            \
}

#define XXX_ENUM(NAME,TUPLE) XXX_ENUM_INTERNAL(NAME,NAME,TUPLE)
#define XXX_ENUM_CLASS(NAME,TUPLE) XXX_ENUM_INTERNAL(class NAME,NAME,TUPLE)
#define XXX_ENUM_CLASS_TYPE(NAME,TYPE,TUPLE) XXX_ENUM_INTERNAL(class NAME : TYPE,NAME,TUPLE)
#define XXX_ENUM_TYPE(NAME,TYPE,TUPLE) XXX_ENUM_INTERNAL(NAME : TYPE,NAME,TUPLE)

用法

#include "xxx_enum.h"  // the above lib
#include <iostream>

XXX_ENUM(foo,(a,b,(c,42)));

int main()
{
  std::cout << "foo::a = "            << foo::a            <<'\n';
  std::cout << "(int)foo::c = "       << (int)foo::c       <<'\n';
  std::cout << "to_string(foo::b) = " << to_string(foo::b) <<'\n';
  std::cout << "xxx::enum_cast<foo>(\"b\") = " << xxx::enum_cast<foo>("b") <<'\n';
}

编译（在中复制粘贴标头`main.cpp`）

> g++ --version | sed 1q
g++ (GCC) 4.9.2

> g++ -std=c++14 -pedantic -Wall -Wextra main.cpp
main.cpp:268:31: warning: extra ';' [-Wpedantic]
     XXX_ENUM(foo,(a,b,(c,42)));
                               ^

输出量

foo::a = foo::a
(int)foo::c = 42
to_string(foo::b) = foo::b
xxx::enum_cast<foo>("b") = foo::b

— 血浆HH
source

5

此代码块是疯狂之旅，穿越了元编程黑魔法的奇妙景观。到达目的地后，我真的感到放心了main–温馨的家！

— 2015年

刚刚在coliru中添加了一个链接以检查输出（有一些警告，请单击您答案中的链接）。我也分为Lib /用法。东西namespace xxx可以移到标题位置吗？您可以在介绍中说出您的用法boost/preprocessor.hpp，因此答案是符合现代C ++的。请修正警告并清理一下源代码，以提高质量。

— olibre

@olibre：这是我认为库中有5个不同的标头的copypastad。enum_cast来自另一个更通用的部分，但是我认为也要添加它，以查看宏中的do_enum_cast的作用。.警告仅来自于我main<tab>的vim，包括我不使用的args。我不认为这段代码可以真正清除，只是为了表明可以做什么，而不应该这样做;）如果我在这里进行更改，它就不再是我在生产中使用的代码了……这是那些脆弱的事情之一一旦开始运作，您最好不要触摸它，因为它可能会以没人能预料的方式崩溃。

— PlasmaHH 2015年

好的等离子，我认为这可以看作是概念证明。但是，有太多的宏开销无法接受。不过，感谢您的分享。干杯

— olibre 2015年

嗨，等离子我已经执行了一个深层的源代码清理工作，并通过编译和运行输出完成了工作。请检查我的编辑。我希望这对您来说可以。答案是否更有价值？但是，宏开销仍然是可怕的！祝你有美好的一天:-)干杯

— olibre 2015年

2

以下解决方案基于std::array<std::string,N>给定枚举的。

为了enum进行std::string转换，我们可以将枚举强制转换为size_t并从数组中查找字符串。该操作为O（1），不需要分配堆。

#include <boost/preprocessor/seq/transform.hpp>
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/stringize.hpp>

#include <string>
#include <array>
#include <iostream>

#define STRINGIZE(s, data, elem) BOOST_PP_STRINGIZE(elem)

// ENUM
// ============================================================================
#define ENUM(X, SEQ) \
struct X {   \
    enum Enum {BOOST_PP_SEQ_ENUM(SEQ)}; \
    static const std::array<std::string,BOOST_PP_SEQ_SIZE(SEQ)> array_of_strings() { \
        return {{BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(STRINGIZE, 0, SEQ))}}; \
    } \
    static std::string to_string(Enum e) { \
        auto a = array_of_strings(); \
        return a[static_cast<size_t>(e)]; \
    } \
}

为了std::string进行enum转换，我们将不得不在数组上进行线性搜索并将数组索引转换为enum。

在此处尝试使用用法示例：http : //coliru.stacked-crooked.com/a/e4212f93bee65076

编辑：重做我的解决方案，以便可以在类中使用自定义枚举。

— 卡卡里亚
source

感谢您的有趣回答。请重新编写您的提案，以便在课程中使用宏。参见coliru.stacked-crooked.com/a/00d362eba836d04b此外，请尽可能尝试使用constexpr和noexept关键字。干杯：-)

— olibre

问题未指定此必要条件。

— FKaria '16

问题已更新（请参见示例）。其他两个要求：（1）枚举的支持类型和（2）值可以不同于序列0、1、2 ...

— olibre

我重新设计了可以在类中使用的解决方案。我还没有弄清楚如何使值不同于0,1,2，..。

— FKaria '16

嗨，FKaria。非常感谢您的返工。为了支持同一个类中的多个枚举并支持enum class X : Type格式，我做了一些更改。请查看我的贡献：coliru.stacked-crooked.com/a/b02db9190d3491a3您如何看待我的更改？您是否有想法支持枚举中设置的值？enum E{A=3, B=6, C=A-B};欢呼示例

— olibre

2

这个要点提供了基于C ++可变参数模板的简单映射。

这是gist中基于类型的映射的C ++ 17简化版本：

#include <cstring> // http://stackoverflow.com/q/24520781

template<typename KeyValue, typename ... RestOfKeyValues>
struct map {
  static constexpr typename KeyValue::key_t get(const char* val) noexcept {
    if constexpr (sizeof...(RestOfKeyValues)==0)  // C++17 if constexpr
      return KeyValue::key; // Returns last element
    else {
      static_assert(KeyValue::val != nullptr,
                  "Only last element may have null name");
      return strcmp(val, KeyValue::val()) 
            ? map<RestOfKeyValues...>::get(val) : KeyValue::key;
    }
  }
  static constexpr const char* get(typename KeyValue::key_t key) noexcept {
    if constexpr (sizeof...(RestOfKeyValues)==0)
      return (KeyValue::val != nullptr) && (key == KeyValue::key)
            ? KeyValue::val() : "";
    else
      return (key == KeyValue::key) 
            ? KeyValue::val() : map<RestOfKeyValues...>::get(key);
  }
};

template<typename Enum, typename ... KeyValues>
class names {
  typedef map<KeyValues...> Map;
public:
  static constexpr Enum get(const char* nam) noexcept {
    return Map::get(nam);
  }
  static constexpr const char* get(Enum key) noexcept {
    return Map::get(key);
  }
};

用法示例：

enum class fasion {
    fancy,
    classic,
    sporty,
    emo,
    __last__ = emo,
    __unknown__ = -1
};

#define NAME(s) static inline constexpr const char* s() noexcept {return #s;}
namespace name {
    NAME(fancy)
    NAME(classic)
    NAME(sporty)
    NAME(emo)
}

template<auto K, const char* (*V)()>  // C++17 template<auto>
struct _ {
    typedef decltype(K) key_t;
    typedef decltype(V) name_t;
    static constexpr key_t  key = K; // enum id value
    static constexpr name_t val = V; // enum id name
};

typedef names<fasion,
    _<fasion::fancy, name::fancy>,
    _<fasion::classic, name::classic>,
    _<fasion::sporty, name::sporty>,
    _<fasion::emo, name::emo>,
    _<fasion::__unknown__, nullptr>
> fasion_names;

所述map<KeyValues...>可以在两个方向中使用：

fasion_names::get(fasion::emo)
fasion_names::get("emo")

该示例可在godbolt.org上找到

int main ()
{
  constexpr auto str = fasion_names::get(fasion::emo);
  constexpr auto fsn = fasion_names::get(str);
  return (int) fsn;
}

结果来自 gcc-7 -std=c++1z -Ofast -S

main:
        mov     eax, 3
        ret

— Hutorny
source

1

非常有趣的元编程方式。我试图简化答案以使其具有自治性（不依赖于Gist链接）。为了简明易懂，我终于对您的答案做了很多编辑。您是否仍然同意我的更改？干杯；-)

— olibre

2

很长一段时间以来，我对这个问题以及使类型正确转换为字符串的问题感到沮丧。但是，对于最后一个问题，我对“ 可以在标准C ++中打印变量类型吗？ ”中解释的解决方案感到惊讶。，可以使用constexpr中的方法获取C ++类型名称吗？。使用这种技术，可以构造一个类似的函数来将枚举值作为字符串获取：

#include <iostream>
using namespace std;

class static_string
{
    const char* const p_;
    const std::size_t sz_;

public:
    typedef const char* const_iterator;

    template <std::size_t N>
    constexpr static_string(const char(&a)[N]) noexcept
        : p_(a)
        , sz_(N - 1)
    {}

    constexpr static_string(const char* p, std::size_t N) noexcept
        : p_(p)
        , sz_(N)
    {}

    constexpr const char* data() const noexcept { return p_; }
    constexpr std::size_t size() const noexcept { return sz_; }

    constexpr const_iterator begin() const noexcept { return p_; }
    constexpr const_iterator end()   const noexcept { return p_ + sz_; }

    constexpr char operator[](std::size_t n) const
    {
        return n < sz_ ? p_[n] : throw std::out_of_range("static_string");
    }
};

inline std::ostream& operator<<(std::ostream& os, static_string const& s)
{
    return os.write(s.data(), s.size());
}

/// \brief Get the name of a type
template <class T>
static_string typeName()
{
#ifdef __clang__
    static_string p = __PRETTY_FUNCTION__;
    return static_string(p.data() + 30, p.size() - 30 - 1);
#elif defined(_MSC_VER)
    static_string p = __FUNCSIG__;
    return static_string(p.data() + 37, p.size() - 37 - 7);
#endif

}

namespace details
{
    template <class Enum>
    struct EnumWrapper
    {
        template < Enum enu >
        static static_string name()
        {
#ifdef __clang__
            static_string p = __PRETTY_FUNCTION__;
            static_string enumType = typeName<Enum>();
            return static_string(p.data() + 73 + enumType.size(), p.size() - 73 - enumType.size() - 1);
#elif defined(_MSC_VER)
            static_string p = __FUNCSIG__;
            static_string enumType = typeName<Enum>();
            return static_string(p.data() + 57 + enumType.size(), p.size() - 57 - enumType.size() - 7);
#endif
        }
    };
}

/// \brief Get the name of an enum value
template <typename Enum, Enum enu>
static_string enumName()
{
    return details::EnumWrapper<Enum>::template name<enu>();
}

enum class Color
{
    Blue = 0,
    Yellow = 1
};


int main() 
{
    std::cout << "_" << typeName<Color>() << "_"  << std::endl;
    std::cout << "_" << enumName<Color, Color::Blue>() << "_"  << std::endl;
    return 0;
}

上面的代码仅在Clang（请参阅https://ideone.com/je5Quv）和VS2015 上进行了测试，但应通过在整数常量上加一点点，使其适用于其他编译器。当然，它仍然在后台使用宏，但是至少一个不需要访问枚举实现。

— 伊格纳斯
source

对于g ++ 6.3.0和C ++ 14，此操作将失败。

— einpoklum

有趣的是，可以正常声明枚举而不必将其包装在宏中。虽然我不喜欢编译器依赖性和魔术常数。

— zett42

2

我从@antron那里得到了这个想法，并以不同的方式实现了它：生成一个真正的枚举类。

此实现满足原始问题中列出的所有要求，但目前只有一个实际限制：它假定未提供枚举值，或者，如果提供，则枚举值必须以0开头并顺次递增而没有间隔。

这不是一个固有的限制-只是我不使用临时枚举值。如果需要的话，可以用传统的开关/情况实现代替向量查找。

该解决方案将一些c ++ 17用于内联变量，但是可以根据需要轻松避免这种情况。由于简单，它也使用boost：trim。

最重要的是，它只需要30行代码，并且不需要黑魔法宏。代码如下。它应放在标头中并包含在多个编译模块中。

可以按照此线程前面建议的方式使用它：

ENUM(Channel, int, Red, Green = 1, Blue)
std::out << "My name is " << Channel::Green;
//prints My name is Green

请让我知道这是否有用以及如何进一步改进。

#include <boost/algorithm/string.hpp>   
struct EnumSupportBase {
  static std::vector<std::string> split(const std::string s, char delim) {
    std::stringstream ss(s);
    std::string item;
    std::vector<std::string> tokens;
    while (std::getline(ss, item, delim)) {
        auto pos = item.find_first_of ('=');
        if (pos != std::string::npos)
            item.erase (pos);
        boost::trim (item);
        tokens.push_back(item);
    }
    return tokens;
  }
};
#define ENUM(EnumName, Underlying, ...) \
    enum class EnumName : Underlying { __VA_ARGS__, _count }; \
    struct EnumName ## Support : EnumSupportBase { \
        static inline std::vector<std::string> _token_names = split(#__VA_ARGS__, ','); \
        static constexpr const char* get_name(EnumName enum_value) { \
            int index = (int)enum_value; \
            if (index >= (int)EnumName::_count || index < 0) \
               return "???"; \
            else \
               return _token_names[index].c_str(); \
        } \
    }; \
    inline std::ostream& operator<<(std::ostream& os, const EnumName & es) { \
        return os << EnumName##Support::get_name(es); \
    }

— 尤里·芬克斯坦（Yuri Finkelstein）
source

2

只要您可以.h/.cpp为每个可查询的枚举编写一个单独的对，此解决方案就可以使用与常规c ++枚举几乎相同的语法和功能：

// MyEnum.h
#include <EnumTraits.h>
#ifndef ENUM_INCLUDE_MULTI
#pragma once
#end if

enum MyEnum : int ETRAITS
{
    EDECL(AAA) = -8,
    EDECL(BBB) = '8',
    EDECL(CCC) = AAA + BBB
};

该.cpp文件是样板的3行：

// MyEnum.cpp
#define ENUM_DEFINE MyEnum
#define ENUM_INCLUDE <MyEnum.h>
#include <EnumTraits.inl>

用法示例：

for (MyEnum value : EnumTraits<MyEnum>::GetValues())
    std::cout << EnumTraits<MyEnum>::GetName(value) << std::endl;

码

此解决方案需要2个源文件：

// EnumTraits.h
#pragma once
#include <string>
#include <unordered_map>
#include <vector>

#define ETRAITS
#define EDECL(x) x

template <class ENUM>
class EnumTraits
{
public:
    static const std::vector<ENUM>& GetValues()
    {
        return values;
    }

    static ENUM GetValue(const char* name)
    {
        auto match = valueMap.find(name);
        return (match == valueMap.end() ? ENUM() : match->second);
    }

    static const char* GetName(ENUM value)
    {
        auto match = nameMap.find(value);
        return (match == nameMap.end() ? nullptr : match->second);
    }

public:
    EnumTraits() = delete;

    using vector_type = std::vector<ENUM>;
    using name_map_type = std::unordered_map<ENUM, const char*>;
    using value_map_type = std::unordered_map<std::string, ENUM>;

private:
    static const vector_type values;
    static const name_map_type nameMap;
    static const value_map_type valueMap;
};

struct EnumInitGuard{ constexpr const EnumInitGuard& operator=(int) const { return *this; } };
template <class T> constexpr T& operator<<=(T&& x, const EnumInitGuard&) { return x; }

...和

// EnumTraits.inl
#define ENUM_INCLUDE_MULTI

#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

using EnumType = ENUM_DEFINE;
using TraitsType = EnumTraits<EnumType>;
using VectorType = typename TraitsType::vector_type;
using NameMapType = typename TraitsType::name_map_type;
using ValueMapType = typename TraitsType::value_map_type;
using NamePairType = typename NameMapType::value_type;
using ValuePairType = typename ValueMapType::value_type;

#define ETRAITS ; const VectorType TraitsType::values
#define EDECL(x) EnumType::x <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

#define ETRAITS ; const NameMapType TraitsType::nameMap
#define EDECL(x) NamePairType(EnumType::x, #x) <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

#define ETRAITS ; const ValueMapType TraitsType::valueMap
#define EDECL(x) ValuePairType(#x, EnumType::x) <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

说明

此实现利用了以下事实：枚举定义的元素的支撑列表也可以用作类成员初始化的支撑初始化列表。

当ETRAITS在上下文中被评估EnumTraits.inl，它膨胀出为一个静态成员定义EnumTraits<>该类。

在EDECL随后为了获得通过成为会员构造宏将每个枚举成员到初始化列表值来填充枚举信息。

该EnumInitGuard课程旨在消耗枚举初始化值，然后崩溃-离开枚举数据的纯名单。

好处

c++类语法
两者enum和enum class（*几乎）
效劳于 enum具有任何数字基础类型的类型
效劳于 enum具有自动，显式和分段初始化器值的类型
适用于批量重命名（保留了智能链接）
仅5个预处理器符号（全局3个）

* 与相比，引用相同枚举中的其他值的类型中的enums初始enum class值设定项必须具有完全限定的值

弊端

.h/.cpp每个可查询项都需要一个单独的对enum
取决于混乱macro和include魔术
较小的语法错误会演变成更大的错误
定义class或namespace限定范围的枚举并非易事
没有编译时初始化

注释

Intellisense在打开时会抱怨私有成员访问EnumTraits.inl，但是由于扩展的宏实际上是在定义类成员，所以这实际上不是问题。

#ifndef ENUM_INCLUDE_MULTI头文件顶部的块是一个小麻烦，可以将其压缩为宏或其他内容，但它足够小，可以按当前大小使用。

声明一个命名空间范围的枚举要求首先将该枚举在其命名空间范围内预先声明，然后在全局命名空间中定义。此外，任何使用相同枚举值的枚举初始化器都必须具有完全限定的值。

namespace ns { enum MyEnum : int; }
enum ns::MyEnum : int ETRAITS
{
    EDECL(AAA) = -8,
    EDECL(BBB) = '8',
    EDECL(CCC) = ns::MyEnum::AAA + ns::MyEnum::BBB
}

— 詹森·林（Jason Lim）
source

2

我不确定其他答案之一是否已经涵盖了这种方法（实际上是，请参见下文）。我多次遇到问题，没有找到没有使用混淆的宏或第三方库的解决方案。因此，我决定编写自己的混淆宏版本。

我要启用的等效于

enum class test1 { ONE, TWO = 13, SIX };

std::string toString(const test1& e) { ... }

int main() {
    test1 x;
    std::cout << toString(x) << "\n";
    std::cout << toString(test1::TWO) << "\n";
    std::cout << static_cast<std::underlying_type<test1>::type>(test1::TWO) << "\n";
    //std::cout << toString(123);// invalid
}

应该打印

ONE
TWO
13

我不喜欢宏。但是，除非c ++本身支持将枚举转换为字符串，否则必须使用某种代码生成和/或宏（而且我怀疑这会过早发生）。我正在使用X宏：

// x_enum.h
#include <string>
#include <map>
#include <type_traits>
#define x_begin enum class x_name {
#define x_val(X) X
#define x_value(X,Y) X = Y
#define x_end };
x_enum_def
#undef x_begin
#undef x_val
#undef x_value
#undef x_end

#define x_begin inline std::string toString(const x_name& e) { \
                static std::map<x_name,std::string> names = { 
#define x_val(X)      { x_name::X , #X }
#define x_value(X,Y)  { x_name::X , #X }
#define x_end }; return names[e]; }
x_enum_def
#undef x_begin
#undef x_val
#undef x_value
#undef x_end
#undef x_name
#undef x_enum_def

它大部分是定义和未定义的符号，用户将通过包含将它们作为参数传递给X-marco。用法是这样的

#define x_name test1
#define x_enum_def x_begin x_val(ONE) , \
                           x_value(TWO,13) , \
                           x_val(SIX) \
                   x_end
#include "x_enum.h"

现场演示

注意，我还没有选择基础类型。到目前为止，我并不需要它，但是直接修改它以启用它应该是直接的。

仅在写完这篇文章后，我才意识到它与eferions答案非常相似。也许我以前读过它，也许它是灵感的主要来源。在编写我自己的;）之前，我总是无法理解X-宏。

— idclev 463035818
source

1

在类/结构（使用公共成员的结构默认值）和重载运算符中使用枚举的解决方案：

struct Color
{
    enum Enum { RED, GREEN, BLUE };
    Enum e;

    Color() {}
    Color(Enum e) : e(e) {}

    Color operator=(Enum o) { e = o; return *this; }
    Color operator=(Color o) { e = o.e; return *this; }
    bool operator==(Enum o) { return e == o; }
    bool operator==(Color o) { return e == o.e; }
    operator Enum() const { return e; }

    std::string toString() const
    {
        switch (e)
        {
        case Color::RED:
            return "red";
        case Color::GREEN:
            return "green";
        case Color::BLUE:
            return "blue";
        default:
            return "unknown";
        }
    }
};

从外部看，它几乎完全像一个类枚举：

Color red;
red = Color::RED;
Color blue = Color::BLUE;

cout << red.toString() << " " << Color::GREEN << " " << blue << endl;

这将输出“ red 1 2”。您可能会重载<<以使蓝色输出成为字符串（尽管这可能会引起歧义，因此不可能），但是它不适用于Color :: GREEN，因为它不会自动转换为Color。

隐式转换为Enum的目的（隐式转换为给定的int或类型）是为了能够：

Color color;
switch (color) ...

这可行，但也意味着这项工作：

int i = color;

对于枚举类，它将无法编译。如果要重载两个带有枚举和整数的函数，或者删除隐式转换，则应小心。

另一种解决方案将涉及使用实际的枚举类和静态成员：

struct Color
{
    enum class Enum { RED, GREEN, BLUE };
    static const Enum RED = Enum::RED, GREEN = Enum::GREEN, BLUE = Enum::BLUE;

    //same as previous...
};

它可能会占用更多空间，并且制作时间更长，但会导致针对隐式int转换的编译错误。我会因为这个而使用它！

虽然肯定有开销，但是我认为它比我见过的其他代码更简单并且看起来更好。也有可能添加功能，所有功能都可以在该类中进行定义。

编辑：这有效，并且大多数可以在执行之前进行编译：

class Color
{
public:
    enum class Enum { RED, GREEN, BLUE };
    static const Enum RED = Enum::RED, GREEN = Enum::GREEN, BLUE = Enum::BLUE;

    constexpr Color() : e(Enum::RED) {}
    constexpr Color(Enum e) : e(e) {}

    constexpr bool operator==(Enum o) const { return e == o; }
    constexpr bool operator==(Color o) const { return e == o.e; }
    constexpr operator Enum() const { return e; }

    Color& operator=(Enum o) { const_cast<Enum>(this->e) = o; return *this; }
    Color& operator=(Color o) { const_cast<Enum>(this->e) = o.e; return *this; }

    std::string toString() const
    {
        switch (e)
        {
        case Enum::RED:
            return "red";
        case Enum::GREEN:
            return "green";
        case Enum::BLUE:
            return "blue";
        default:
            return "unknown";
        }
    }
private:
    const Enum e;
};

— 帕特·劳
source

这非常有趣：-)但是，您当前的版本暗示您必须手动编写内容case Enum::RED: return "red";。问题是关于由编译器（在编译时）自动执行此操作。问题的想法是仅更改或添加枚举值，而不必更新内容toString()。你有看到？谢谢

— olibre

1

一个非常简单的解决方案，但有一个很大的约束：您不能将自定义值分配给enum值，但是可以使用正确的正则表达式来实现。您还可以添加一张地图，将它们转换回enum值，而无需付出更多的努力：

#include <vector>
#include <string>
#include <regex>
#include <iterator>

std::vector<std::string> split(const std::string& s, 
                               const std::regex& delim = std::regex(",\\s*"))
{
    using namespace std;
    vector<string> cont;
    copy(regex_token_iterator<string::const_iterator>(s.begin(), s.end(), delim, -1), 
         regex_token_iterator<string::const_iterator>(),
         back_inserter(cont));
    return cont;
}

#define EnumType(Type, ...)     enum class Type { __VA_ARGS__ }

#define EnumStrings(Type, ...)  static const std::vector<std::string> \
                                Type##Strings = split(#__VA_ARGS__);

#define EnumToString(Type, ...) EnumType(Type, __VA_ARGS__); \
                                EnumStrings(Type, __VA_ARGS__)

用法示例：

EnumToString(MyEnum, Red, Green, Blue);

— Malem
source

感谢Malem的创新想法。我已经编辑了您的答案以提高可读性。我希望你喜欢我的改变。请继续改善您的答案：（1）用类似-的内容扩展“用法示例”部分auto name = MyEnumStrings["Red"];。（2）为什么使用enum class？-（3）您支持enum class MyEnum : char { Red, Green, Blue };吗？-（4）解释功能split()-（5）是否需要参数const std::regex& delim？-（6）MyEnumStrings编译时生成怎么样？=>您可以使用constexpr吗？...干杯：-)

— olibre

我真的很喜欢这种方法。确实简短易懂。

— 安东·霍尔姆伯格

1

编辑：检查下面的较新版本

如上所述，N4113是解决此问题的最终解决方案，但我们将不得不等待一年多的时间才能看到它的出现。

同时，如果您想要这样的功能，则需要使用“简单”模板和一些预处理器魔术。

枚举器

template<typename T>
class Enum final
{
    const char* m_name;
    const T m_value;
    static T m_counter;

public:
    Enum(const char* str, T init = m_counter) : m_name(str), m_value(init) {m_counter = (init + 1);}

    const T value() const {return m_value;}
    const char* name() const {return m_name;}
};

template<typename T>
T Enum<T>::m_counter = 0;

#define ENUM_TYPE(x)      using Enum = Enum<x>;
#define ENUM_DECL(x,...)  x(#x,##__VA_ARGS__)
#define ENUM(...)         const Enum ENUM_DECL(__VA_ARGS__);

用法

#include <iostream>

//the initialization order should be correct in all scenarios
namespace Level
{
    ENUM_TYPE(std::uint8)
    ENUM(OFF)
    ENUM(SEVERE)
    ENUM(WARNING)
    ENUM(INFO, 10)
    ENUM(DEBUG)
    ENUM(ALL)
}

namespace Example
{
    ENUM_TYPE(long)
    ENUM(A)
    ENUM(B)
    ENUM(C, 20)
    ENUM(D)
    ENUM(E)
    ENUM(F)
}

int main(int argc, char** argv)
{
    Level::Enum lvl = Level::WARNING;
    Example::Enum ex = Example::C;
    std::cout << lvl.value() << std::endl; //2
    std::cout << ex.value() << std::endl; //20
}

简单说明

Enum<T>::m_counter在每个名称空间声明中设置为0。
（有人可以指出标准上提到^^此行为^^的位置吗？）
预处理器魔术可以自动执行枚举器的声明。

缺点

这不是真正的enum类型，因此无法提升为int
不能用于开关箱

替代解决方案

这个牺牲了行编号（不是真的），但是可以用于开关盒。

#define ENUM_TYPE(x) using type = Enum<x>
#define ENUM(x)      constexpr type x{__LINE__,#x}

template<typename T>
struct Enum final
{
    const T value;
    const char* name;

    constexpr operator const T() const noexcept {return value;}
    constexpr const char* operator&() const noexcept {return name;}
};

勘误

#line 0与-pedanticGCC和clang 冲突。

解决方法

开始于，#line 1然后从减去1 __LINE__。
或者，不要使用-pedantic。
尽管我们不惜一切代价避免使用VC ++，但它一直是编译器的笑话。

用法

#include <iostream>

namespace Level
{
    ENUM_TYPE(short);
    #line 0
    ENUM(OFF);
    ENUM(SEVERE);
    ENUM(WARNING);
    #line 10
    ENUM(INFO);
    ENUM(DEBUG);
    ENUM(ALL);
    #line <next line number> //restore the line numbering
};

int main(int argc, char** argv)
{
    std::cout << Level::OFF << std::endl;   // 0
    std::cout << &Level::OFF << std::endl;  // OFF

    std::cout << Level::INFO << std::endl;  // 10
    std::cout << &Level::INFO << std::endl; // INFO

    switch(/* any integer or integer-convertible type */)
    {
    case Level::OFF:
        //...
        break;

    case Level::SEVERE:
        //...
        break;

    //...
    }

    return 0;
}

现实中的实现和使用

r3dVoxel-枚举
 r3dVoxel-ELoggingLevel

快速参考

＃行LINENO - cppreference.com

— bit2shift
source

0

我写了一个库来解决这个问题，除了获取消息外，所有事情都在编译时发生。

用法：

使用宏DEF_MSG定义宏和消息对：

DEF_MSG(CODE_OK,   "OK!")
DEF_MSG(CODE_FAIL, "Fail!")

CODE_OK是要使用的宏，并且"OK!"是相应的消息。

使用get_message()或仅gm()获取消息：

get_message(CODE_FAIL);  // will return "Fail!"
gm(CODE_FAIL);           // works exactly the same as above

使用MSG_NUM找出多少个宏已经确定。这将自动增加，您无需执行任何操作。

预定义的消息：

MSG_OK:     OK
MSG_BOTTOM: Message bottom

项目：libcodemsg

该库不会创建额外的数据。一切都在编译时发生。在中message_def.h，它产生一个enum被叫MSG_CODE; 在message_def.c，它生成一个变量来存放所有的字符串static const char* _g_messages[]。

在这种情况下，该库仅限于创建一个enum。这是返回值的理想选择，例如：

MSG_CODE foo(void) {
    return MSG_OK; // or something else
}

MSG_CODE ret = foo();

if (MSG_OK != ret) {
    printf("%s\n", gm(ret););
}

我喜欢这种设计的另一件事是，您可以管理不同文件中的消息定义。

我发现该问题的解决方案看起来要好得多。

— 麦温
source

嗨，Madwyn。谢谢你的想法但是它是如何工作的呢？开销是多少？（零开销还是会产生额外的数据？）。您的主张似乎不错，但不幸的是，DEF_MSG必须为每个enum值使用/更新/维护一个语句：-/这是我们理想的选择停止执行的声明...干杯

— olibre 2015年

感谢您的回复，@ olibre。请检查更新后的答案。我在这里看不到开销，只是访问字符串需要函数调用。DEF_MSG使该enum消息与消息紧密配对，尽管它有一些限制。

— Madwyn

谢谢您在回答中附加说明：-)您的lib很好，但不能用于多个枚举：-/ enum class（C ++ 11）的支持如何？您可以在运行时使用constexpr限制_g_messages。使用元编程（类型传递{enum-type，enum-value}）或模板变量（C ++ 14）支持多种enum类型（避免）。我认为您的lib（尚未？）不符合C ++ 11/14/17的要求。你怎么看？干杯；-)_g_messages

— olibre 2015年

1

感谢您的跟进。我今天学了些新东西！枚举类和模板变量看起来不错。我认为我的回答有点像“ C”一样，是“离题”。

— Madwyn 2015年

0

#define ENUM_MAKE(TYPE, ...) \
        enum class TYPE {__VA_ARGS__};\
        struct Helper_ ## TYPE { \
            static const String& toName(TYPE type) {\
                int index = static_cast<int>(type);\
                return splitStringVec()[index];}\
            static const TYPE toType(const String& name){\
                static std::unordered_map<String,TYPE> typeNameMap;\
                if( typeNameMap.empty() )\
                {\
                    const StringVector& ssVec = splitStringVec();\
                    for (size_t i = 0; i < ssVec.size(); ++i)\
                        typeNameMap.insert(std::make_pair(ssVec[i], static_cast<TYPE>(i)));\
                }\
                return typeNameMap[name];}\
            static const StringVector& splitStringVec() {\
                static StringVector typeNameVector;\
                if(typeNameVector.empty()) \
                {\
                    typeNameVector = StringUtil::split(#__VA_ARGS__, ",");\
                    for (auto& name : typeNameVector)\
                    {\
                        name.erase(std::remove(name.begin(), name.end(), ' '),name.end()); \
                        name = String(#TYPE) + "::" + name;\
                    }\
                }\
                return typeNameVector;\
            }\
        };


using String = std::string;
using StringVector = std::vector<String>;

   StringVector StringUtil::split( const String& str, const String& delims, unsigned int maxSplits, bool preserveDelims)
    {
        StringVector ret;
        // Pre-allocate some space for performance
        ret.reserve(maxSplits ? maxSplits+1 : 10);    // 10 is guessed capacity for most case

        unsigned int numSplits = 0;

        // Use STL methods 
        size_t start, pos;
        start = 0;
        do 
        {
            pos = str.find_first_of(delims, start);
            if (pos == start)
            {
                // Do nothing
                start = pos + 1;
            }
            else if (pos == String::npos || (maxSplits && numSplits == maxSplits))
            {
                // Copy the rest of the string
                ret.push_back( str.substr(start) );
                break;
            }
            else
            {
                // Copy up to delimiter
                ret.push_back( str.substr(start, pos - start) );

                if(preserveDelims)
                {
                    // Sometimes there could be more than one delimiter in a row.
                    // Loop until we don't find any more delims
                    size_t delimStart = pos, delimPos;
                    delimPos = str.find_first_not_of(delims, delimStart);
                    if (delimPos == String::npos)
                    {
                        // Copy the rest of the string
                        ret.push_back( str.substr(delimStart) );
                    }
                    else
                    {
                        ret.push_back( str.substr(delimStart, delimPos - delimStart) );
                    }
                }

                start = pos + 1;
            }
            // parse up to next real data
            start = str.find_first_not_of(delims, start);
            ++numSplits;

        } while (pos != String::npos);



        return ret;
    }

例

ENUM_MAKE(MY_TEST, MY_1, MY_2, MY_3)


    MY_TEST s1 = MY_TEST::MY_1;
    MY_TEST s2 = MY_TEST::MY_2;
    MY_TEST s3 = MY_TEST::MY_3;

    String z1 = Helper_MY_TEST::toName(s1);
    String z2 = Helper_MY_TEST::toName(s2);
    String z3 = Helper_MY_TEST::toName(s3);

    MY_TEST q1 = Helper_MY_TEST::toType(z1);
    MY_TEST q2 = Helper_MY_TEST::toType(z2);
    MY_TEST q3 = Helper_MY_TEST::toType(z3);

ENUM_MAKE宏会自动生成带有“枚举反映功能”的“枚举类”和辅助类。

为了减少错误，一次只用一个ENUM_MAKE定义了所有内容。

该代码的优势是自动创建的，用于反射和仔细查看宏代码，这些代码易于理解。“枚举到字符串”，“字符串到枚举”的性能都是算法O（1）。

缺点是在初次使用时，用于枚举引用的字符串向量和映射的辅助类被初始化。但如果您愿意，也将被预先初始化。–

— desperado_98
source

尽管此代码可以回答问题，但最好在不引入其他内容的情况下解释它如何解决该问题以及为什么使用它。从长远来看，纯代码答案没有用。

— 2015年

嘿，对不起，我的英语说得不好。

— desperado_98 2015年

ENUM_MAKE宏会自动生成带有“枚举反映功能”的“枚举类”和辅助类。/为了减少错误，一次只用一个ENUM_MAKE定义了所有内容。该代码的优势是自动创建的，用于反射和仔细查看宏代码，这些代码易于理解。'enum to string'和'string to enum'的性能都是算法O（1）。缺点是在初次使用时，用于枚举的辅助类的字符串向量和映射被初始化。但如果您愿意，也将被预先初始化。

— desperado_98 2015年

嗨desperado_98。感谢您的贡献。请编辑您的答案，并在其中插入您的评论内容。如果您使用一些元编程技巧和，则编译器可以在编译时计算示例constexpr。我的意思是这些功能toName()，toType()可以在编译期间而不是在执行期间（运行时）进行评估。请在回答中采用C ++ 11/14/17样式。干杯；-)

— olibre 2015年

此外：您的宏兼容 enum class MyEnum : short { A, B, C };吗？

— olibre 2015年

0

我的解决方案是没有宏用法。

优点：

你确切地看到你在做什么
访问是通过哈希映射进行的，因此对于许多有价值的枚举都非常有用
无需考虑顺序或非连续值
枚举到字符串和字符串到枚举转换，而添加的枚举值只能在另一个位置添加

缺点：

您需要将所有枚举值复制为文本
哈希映射中的访问必须考虑字符串大小写
如果增加值很麻烦，请进行维护-必须同时添加枚举和直接翻译映射

所以...直到C ++实现C＃Enum.Parse功能的那一天，我都会被困在这里：

            #include <unordered_map>

            enum class Language
            { unknown, 
                Chinese, 
                English, 
                French, 
                German
                // etc etc
            };

            class Enumerations
            {
            public:
                static void fnInit(void);

                static std::unordered_map <std::wstring, Language> m_Language;
                static std::unordered_map <Language, std::wstring> m_invLanguage;

            private:
                static void fnClear();
                static void fnSetValues(void);
                static void fnInvertValues(void);

                static bool m_init_done;
            };

            std::unordered_map <std::wstring, Language> Enumerations::m_Language = std::unordered_map <std::wstring, Language>();
            std::unordered_map <Language, std::wstring> Enumerations::m_invLanguage = std::unordered_map <Language, std::wstring>();

            void Enumerations::fnInit()
            {
                fnClear();
                fnSetValues();
                fnInvertValues();
            }

            void Enumerations::fnClear()
            {
                m_Language.clear();
                m_invLanguage.clear();
            }

            void Enumerations::fnSetValues(void)
            {   
                m_Language[L"unknown"] = Language::unknown;
                m_Language[L"Chinese"] = Language::Chinese;
                m_Language[L"English"] = Language::English;
                m_Language[L"French"] = Language::French;
                m_Language[L"German"] = Language::German;
                // and more etc etc
            }

            void Enumerations::fnInvertValues(void)
            {
                for (auto it = m_Language.begin(); it != m_Language.end(); it++)
                {
                    m_invLanguage[it->second] = it->first;
                }
            }

            // usage -
            //Language aLanguage = Language::English;
            //wstring sLanguage = Enumerations::m_invLanguage[aLanguage];

            //wstring sLanguage = L"French" ;
            //Language aLanguage = Enumerations::m_Language[sLanguage];

— 米娅·沙尼（Mia Shani）
source

0

好吧，还有另一种选择。一个典型的用例是，您需要为HTTP动词及其字符串版本值使用常量。

这个例子：

int main () {

  VERB a = VERB::GET;
  VERB b = VERB::GET;
  VERB c = VERB::POST;
  VERB d = VERB::PUT;
  VERB e = VERB::DELETE;


  std::cout << a.toString() << std::endl;

  std::cout << a << std::endl;

  if ( a == VERB::GET ) {
    std::cout << "yes" << std::endl;
  }

  if ( a == b ) {
    std::cout << "yes" << std::endl;
  }

  if ( a != c ) {
    std::cout << "no" << std::endl;
  }

}

VERB类：

// -----------------------------------------------------------
// -----------------------------------------------------------
class VERB {

private:

  // private constants
  enum Verb {GET_=0, POST_, PUT_, DELETE_};

  // private string values
  static const std::string theStrings[];

  // private value
  const Verb value;
  const std::string text;

  // private constructor
  VERB (Verb v) :
  value(v), text (theStrings[v])
  {
    // std::cout << " constructor \n";
  }

public:

  operator const char * ()  const { return text.c_str(); }

  operator const std::string ()  const { return text; }

  const std::string toString () const { return text; }

  bool operator == (const VERB & other) const { return (*this).value == other.value; }

  bool operator != (const VERB & other) const { return ! ( (*this) == other); }

  // ---

  static const VERB GET;
  static const VERB POST;
  static const VERB PUT;
  static const VERB DELETE;

};

const std::string VERB::theStrings[] = {"GET", "POST", "PUT", "DELETE"};

const VERB VERB::GET = VERB ( VERB::Verb::GET_ );
const VERB VERB::POST = VERB ( VERB::Verb::POST_ );
const VERB VERB::PUT = VERB ( VERB::Verb::PUT_ );
const VERB VERB::DELETE = VERB ( VERB::Verb::DELETE_ );
// end of file

— cibercitizen1
source

1

为了减少内存使用量，您可以将const std::string textjust 替换为member theStrings[v]。但是，问题是关于C ++ 11 / C ++ 14 / C ++ 17 / C ++ 20的功能，以避免不得不手动编写此类：-/

— olibre

0

我的答案在这里。

您可以同时获取枚举值名称和这些索引作为字符串的双端队列。

此方法只需要很少的复制，粘贴和编辑。

当需要枚举类类型值时，获得的结果需要从size_t到枚举类类型的类型转换，但是我认为这是一种处理枚举类的非常可移植且功能强大的方法。

enum class myenum
{
  one = 0,
  two,
  three,
};

deque<string> ssplit(const string &_src, boost::regex &_re)
{
  boost::sregex_token_iterator it(_src.begin(), _src.end(), _re, -1);
  boost::sregex_token_iterator e;
  deque<string> tokens;
  while (it != e)
    tokens.push_back(*it++);
  return std::move(tokens);
}

int main()
{
  regex re(",");
  deque<string> tokens = ssplit("one,two,three", re);
  for (auto &t : tokens) cout << t << endl;
    getchar();
  return 0;
}

— 张量5375
source

0

您可以使用反射库，例如Ponder：

enum class MyEnum
{
    Zero = 0,
    One  = 1,
    Two  = 2
};

ponder::Enum::declare<MyEnum>()
    .value("Zero", MyEnum::Zero)
    .value("One",  MyEnum::One)
    .value("Two",  MyEnum::Two);

ponder::EnumObject zero(MyEnum::Zero);

zero.name(); // -> "Zero"

— 缺口
source

0

（类似https://stackoverflow.com/a/54967187/2338477的模拟）。

这是我自己的解决方案，具有最少的定义魔术和单个枚举分配的支持。

这是头文件：

#pragma once
#include <string>
#include <map>
#include <regex>

template <class Enum>
class EnumReflect
{
public:
    static const char* getEnums() { return ""; }
};

//
//  Just a container for each enumeration type.
//
template <class Enum>
class EnumReflectBase
{
public:
    static std::map<std::string, int> enum2int;
    static std::map<int, std::string> int2enum;

    static void EnsureEnumMapReady( const char* enumsInfo )
    {
        if (*enumsInfo == 0 || enum2int.size() != 0 )
            return;

        // Should be called once per each enumeration.
        std::string senumsInfo(enumsInfo);
        std::regex re("^([a-zA-Z_][a-zA-Z0-9_]+) *=? *([^,]*)(,|$) *");     // C++ identifier to optional " = <value>"
        std::smatch sm;
        int value = 0;

        for (; regex_search(senumsInfo, sm, re); senumsInfo = sm.suffix(), value++)
        {
            string enumName = sm[1].str();
            string enumValue = sm[2].str();

            if (enumValue.length() != 0)
                value = atoi(enumValue.c_str());

            enum2int[enumName] = value;
            int2enum[value] = enumName;
        }
    }
};

template <class Enum>
std::map<std::string, int> EnumReflectBase<Enum>::enum2int;

template <class Enum>
std::map<int, std::string> EnumReflectBase<Enum>::int2enum;


#define DECLARE_ENUM(name, ...)                                         \
    enum name { __VA_ARGS__ };                                          \
    template <>                                                         \
    class EnumReflect<##name>: public EnumReflectBase<##name> {         \
    public:                                                             \
        static const char* getEnums() { return #__VA_ARGS__; }          \
    };




/*
    Basic usage:

    Declare enumeration:

DECLARE_ENUM( enumName,

    enumValue1,
    enumValue2,
    enumValue3 = 5,

    // comment
    enumValue4
);

    Conversion logic:

    From enumeration to string:

        printf( EnumToString(enumValue3).c_str() );

    From string to enumeration:

       enumName value;

       if( !StringToEnum("enumValue4", value) )
            printf("Conversion failed...");
*/

//
//  Converts enumeration to string, if not found - empty string is returned.
//
template <class T>
std::string EnumToString(T t)
{
    EnumReflect<T>::EnsureEnumMapReady(EnumReflect<T>::getEnums());
    auto& int2enum = EnumReflect<T>::int2enum;
    auto it = int2enum.find(t);

    if (it == int2enum.end())
        return "";

    return it->second;
}

//
//  Converts string to enumeration, if not found - false is returned.
//
template <class T>
bool StringToEnum(const char* enumName, T& t)
{
    EnumReflect<T>::EnsureEnumMapReady(EnumReflect<T>::getEnums());
    auto& enum2int = EnumReflect<T>::enum2int;
    auto it = enum2int.find(enumName);

    if (it == enum2int.end())
        return false;

    t = (T) it->second;
    return true;
}

这是示例测试应用程序：

DECLARE_ENUM(TestEnum,
    ValueOne,
    ValueTwo,
    ValueThree = 5,
    ValueFour = 7
);

DECLARE_ENUM(TestEnum2,
    ValueOne2 = -1,
    ValueTwo2,
    ValueThree2 = -4,
    ValueFour2
);

void main(void)
{
    string sName1 = EnumToString(ValueOne);
    string sName2 = EnumToString(ValueTwo);
    string sName3 = EnumToString(ValueThree);
    string sName4 = EnumToString(ValueFour);

    TestEnum t1, t2, t3, t4, t5 = ValueOne;
    bool b1 = StringToEnum(sName1.c_str(), t1);
    bool b2 = StringToEnum(sName2.c_str(), t2);
    bool b3 = StringToEnum(sName3.c_str(), t3);
    bool b4 = StringToEnum(sName4.c_str(), t4);
    bool b5 = StringToEnum("Unknown", t5);

    string sName2_1 = EnumToString(ValueOne2);
    string sName2_2 = EnumToString(ValueTwo2);
    string sName2_3 = EnumToString(ValueThree2);
    string sName2_4 = EnumToString(ValueFour2);

    TestEnum2 t2_1, t2_2, t2_3, t2_4, t2_5 = ValueOne2;
    bool b2_1 = StringToEnum(sName2_1.c_str(), t2_1);
    bool b2_2 = StringToEnum(sName2_2.c_str(), t2_2);
    bool b2_3 = StringToEnum(sName2_3.c_str(), t2_3);
    bool b2_4 = StringToEnum(sName2_4.c_str(), t2_4);
    bool b2_5 = StringToEnum("Unknown", t2_5);

相同头文件的更新版本将保留在这里：

https://github.com/tapika/cppscriptcore/blob/master/SolutionProjectModel/EnumReflect.h

— 塔尔莫·皮卡罗
source

-5

简单的流过载怎么办？如果您不想做一些宏魔术，您仍然必须维护映射，但是我发现它比原始解决方案更干净。

#include <cstdint>  // for std::uint_fast8_t
#include <array>
#include <string>
#include <iostream>

enum class MyEnum : std::uint_fast8_t {
   AAA,
   BBB,
   CCC,
};

std::ostream& operator<<(std::ostream& str, MyEnum type)
{
    switch(type)
    {
    case MyEnum::AAA: str << "AAA"; break;
    case MyEnum::BBB: str << "BBB"; break;
    case MyEnum::CCC: str << "CCC"; break;
    default: break;
    }
    return str;
}

int main()
{
   std::cout << MyEnum::AAA <<'\n';
}

— dau_sama
source

5

1）它创建了更多重复项2）它强迫您使用流

— Karoly Horvath

6

-1对不起@dau_sama，但是所有这些枚举对字符串重复出现的问题的目的是避免维护枚举/字符串映射。如果您认为答案不符合目的，请考虑删除答案。祝您下一个答案好运；）干杯

— olibre 2015年

-9

最简单的方法？
使用Ada：Enumeration'Image( Value )完全满足您的需求。如果您确实需要C ++，则可以尝试导出该函数：

Function To_String( Input : Enumeration ) return Interfaces.C.Strings.chars_ptr is
    ( Interfaces.C.Strings.New_String( Enumeration'Image(Input) ) )
    with Export, Convention => C;

— 鲨鱼8
source

4

这怎么回答这个问题？该问题明确指出在现代C ++中将枚举转换为字符串。

— 迈克尔·崔

1

@MichaelChoi -确实如此，但也有使用适合工作的正确工具的问题：仅仅因为C ++是图灵完备，因此可以解决所有可以解决的问题并不意味着该解决方案是：速度快，易于维护，或有效率。使用具有适当/所需功能的语言并将其导出是一种有效的解决方案。

— Shark8

3

在问题的第一句中，“此问题与使用新的C ++功能有关”。然后使用[[我尚未找到任何]使用C ++ 11，C ++ 14或C ++ 17新功能的优雅方法”。作者显然正在寻找C ++解决方案。您在Ada中提供了解决方案，所以您没有回答问题。您建议合并一个完全不同的依赖项，以解决问题范围之外的问题。

— 迈克尔·崔

在现代C ++ 11 / C ++ 14 / C ++ 17和未来的C ++ 20中枚举为字符串

与所有其他类似问题相反，该问题与使用新的C ++功能有关。

阅读许多答案后，我尚未找到任何答案：

例

约束条件

很高兴有

Magic Enum仅标头库为C ++ 17提供了枚举（到字符串，字符串，迭代）的静态反射。

缺点在哪里？

说明

码

编辑

更新：

库（合并到一个头文件中）

用法

编译（在中复制粘贴标头main.cpp）

输出量

码

说明

好处

弊端

注释

编辑：检查下面的较新版本

枚举器

用法

简单说明

缺点

替代解决方案

勘误

解决方法

用法

现实中的实现和使用

快速参考

用法：

编译（在中复制粘贴标头`main.cpp`）