他のすべての同様の質問とは異なり、この質問は新しい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フレンドリーなスニペット

考えられる1つのアイデアは、C ++コンパイラ機能を使用してvariadic template class、constexpr関数と関数に基づくメタプログラミングトリックを使用してコンパイル時にC ++コードを生成することです...

— オリーブ
ソース

4

（たぶん話題の）このQt関連のブログを見てください。woboq.com/blog/reflection-in-cpp-and-qt-moc.html。C ++リフレクション（標準案）を使用してQtのmoc（メタオブジェクトコンパイラ）を置き換える可能性について説明します。

— ibre5041

10

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

— ecatmur

1

私は個人的に、可変プリプロセッサマクロの引数をループしてそれらすべてに対して関数を実行できる小さなプリプロセッサユーティリティライブラリを実装することで、この問題を解決しました。enum値をマクロ引数として渡し、プリプロセッサを介してenumと文字列配列を自動的に生成します。おそらくこれもBoost Preprocessorを使用して行うことができます。

— Vittorio Romeo

2

C ++ですべてを解決する必要がありますか？文字列表現のコードを数行だけで自動生成するのはとても簡単です。

— Karoly Horvath 2015

2

あなたがC ++ 17のを待つことをいとわない限りそこに何も使用できるが、ほとんどありません、それはない、よく「可能ならばCマクロベースの答えを提供しないでください」という悪いとしてあなたの列挙型を宣言するためにDEC_ENUM(enumname, (a,b,c,(d,b),(e,42)))あなたがMAINTAINTする必要がない限り、マクロを生成する...そして、そのようなケースを言語に入れる私見は、より強力なテンプレート/マクロのハイブリッドの代わりのハックの一種にすぎません。マクロがもはや役に立たないと言うためだけに、これらのマクロの有用なユースケースをすべて言語に追加するべきではありません。

— PlasmaHH 2015

43

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
ソース

なぜ範囲が制限されるのですか？それはある種の再帰の深さを制限するためですか、それともある種のコンパイル時の線形検索のためですか？

— エミールCormier

これは素晴らしいです。ありがとうございました！コンパイラがconstexpr std :: arrayを1回だけ評価できるほど賢い場合は、おそらくさらに効率的です。とってもとっても素敵。

— 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リフレクションの提案を実装することもできます。

マクロは1つだけです。#現在のC ++では、プリプロセッサの文字列化（）がトークンを文字列に変換する唯一の方法であるため、これは可能な限り最小限であると考えています。
マクロは控えめです。初期化子を含む定数宣言は、組み込みの列挙型宣言に貼り付けられます。つまり、組み込みの列挙型と同じ構文と意味を持っています。
繰り返しがなくなります。
の実装により、実装は最も自然で、少なくともC ++ 11で役立ちconstexprます。C ++ 98 +で動作するようにすることもでき__VA_ARGS__ます。間違いなく最新のC ++です。

マクロの定義はいくぶん複雑なので、いくつかの方法でこれに答えています。

この回答の大部分は、StackOverflowのスペース制約に適していると思う実装です。
長い形式のチュートリアルの実装の基本を説明するCodeProjectの記事もあります。[ ここに移動しますか？SOの答えとしては多すぎると思います ]。
マクロを単一のヘッダーファイルに実装するフル機能のライブラリ「Better Enums」があります。また、C ++ 17リフレクションプロポーザルN4113の現在のリビジョンであるN4428 Type Property Queriesも実装しています。したがって、少なくともこのマクロを介して宣言された列挙型については、提案されているC ++ 17列挙型リフレクションをC ++ 11 / C ++ 14で使用できます。

この回答をライブラリの機能に拡張するのは簡単です。ここでは「重要」な点は省略されていません。ただし、これは非常に退屈であり、コンパイラの移植性に関する懸念があります。

免責事項：私はCodeProjectの記事とライブラリの両方の著者です。

あなたは試すことができ、この答えのコード、ライブラリ、およびN4428の実施を Wandboxでライブオンライン。ライブラリのドキュメントには、それを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}は、値の配列の初期化子のようなものになります。はRed代入可能な式ではないため、これは有効なC ++ではありません。これは、各定数を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静的インライン関数での通常の配列の2つの可能な解決策があります。この回答のコードは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"コンパイル時に列挙型に変換されたことにも注意してください。

— アントロン
ソース

Heya @mrhthepie、編集が拒否されました。私はそれについてのメールを見ました。私はそれを答えに組み込みます–バグ修正に感謝します！

— antron

これは素晴らしい。ビットの列挙が必要な場合にもこれは機能しますか？BitFlagsの列挙が必要なように、それぞれが1Uいくらかシフトされますか？

— user3240688

1

_trimmed_names()ここに投稿したコードにメモリリークがあるようです（new char[length + 1]ただしinitialized、trueに設定していません）。私は何かを逃していますか？私はあなたのgithubコードに同じ問題を見ません。

— user3240688 2016年

1

これはに設定されてtrueいますが、ifブランチの外にあります（@mrhthepieによって最初にキャッチされたメモリリーク）。内部に移動する必要があります...編集しています。これとGHコードの両方をよく見ていただきありがとうございます。

— antron 2016年

1

to_stringstring_viewnull終了を必要としないC ++ 17からを返し、constexprになる可能性があります。

— Yakk-Adam Nevraumont 2017

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>
  >

例（clangのMatus Choclikの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に入れると確信しています。ハーブサッターの旅レポート：

特に、Reflection研究グループは最新の統合静的反射提案をレビューし、次回の会議で主要なEvolutionグループに参加して、TSまたは次の標準の統合静的反射提案を検討する準備ができていることを発見しました。

— ecatmur
ソース

2

@antronさん、編集が拒否されました。時間内に見ていれば承認しました。N4428を見たことがないので、頭を上げてくれてありがとう。

— ecatmur

3

組み込んでくれてありがとう。どうして却下されたのかしら。「正確ではない」というボイラープレートの理由はわかりますが、今日の方が明らかに正確です。

— アントロン2015

1

ありがとう:-)水平スクロールバーを回避するために、最後の例を分割しました。残念値がMyEnum::AAAの2番目の引数として渡すことはできませんstd::meta::get_enumerators_m： - /

— olibre

1

このような概念的に単純なタスクが3レベルのネストされたテンプレート引数を必要とするという事実は、非常に高度に設計されています。特定の技術的な理由があると私は確信しています。しかし、それは最終結果がユーザーフレンドリーであるという意味ではありません。私はC ++が大好きで、コードは私にとって理にかなっています。しかし、私が日常的に使用している他のプログラマーの90％は、このようなコードのためにC ++を避けています。より単純な組み込みのソリューションを見たことがないことに失望しています。

— void.pointer 2018

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);

次のコードは、enumクラスとオーバーロードを自動的に作成します。

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

— ダニーロ・ラモス
ソース

1

このマクロ定義内に改行を入れることはできますか？

— einpoklum 2018年

1

*列挙型のカウントを取得するためにのオーバーロードを追加しました...気にしないでください:-)

— Peter VARGA

1

この実装std::mapがstd::unordered_map（O（1）インデックス）ではなく（O（log（n））インデックス）を使用する理由はありますか？

— タム川

1

また、inlineリンカーに「複数の定義」エラーが発生することなく、通常のようにヘッダーファイルで列挙型を宣言できるように、メソッドにマークを付ける必要があると思います。（しかし、それが実際に最もクリーンで最善の解決策かどうかはわかりません）

— River Tam

1

（スパムで申し訳ありませんが、今日はコメントを編集できないようです）これがヘッダーファイルにあると、他の問題があります。マップ（E##MapName）は、enumにもアクセスできるコンパイルユニットに移動する必要があります。ソリューションを作成しましたが、あまりクリーンではないため、共有するための許可を得る必要があります。とりあえず、ヘッダーファイルでの使用をサポートするために必要な追加機能がなければ、メソッドをインラインでマークしても意味がないとコメントするだけです。

— タム川

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);
}

そして、それが私がやって来る方法です。

enum文字列化のネイティブサポートははるかに優れています。C ++ 17のリフレクションワークグループの結果を確認することに非常に興味があります。

これを行う別の方法は、@ seheのコメントに投稿されています。

— StackedCrooked
ソース

1

私はまさにこれをします。私は通常、道に沿ってサラウンドのvimとブロック選択を使用していますが

— sehe

@sehe興味深い。現在、多くのキーストロークに対応する方法が必要なため、「サラウンド」を確認する必要があります。

— StackedCrooked 2015年

ここでは完全に悲惨で、マクロはありません（.カウントを除く）：i.imgur.com/gY4ZhBE.gif

— sehe

1

アニメーションgifはかわいいですが、いつ始まり、いつ終わるのか、どこまで進んでいるのかはわかりません。...実際には、それを引っ掻く、それはかわいいではありません、それは気が散ります。私はそれを殺すと言います。

— einpoklum 2018年

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

編集する

不思議user673679あなたは正しいです。C ++ 14変数テンプレートアプローチはランタイムのケースを処理しません。それを忘れるのは私の責任でした:(

しかし、いくつかの最新のC ++機能と変数テンプレートに加えて可変テンプレートのトリックを使用して、列挙値から文字列へのランタイム変換を実現できます。

enum-to-stringマップへのアクセスを短くするために、テンプレートエイリアスの使用を開始しましょう。

// 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

— PaperBirdMaster
ソース

これはかなりきれいに見えます（特殊化されていない変数を定義しないことは可能ですか？）。ランタイムケースの処理方法がまったくわからないためですが、何か不足している可能性があります。

— user673679

@Paula_plus_plus：std::array扱いにくいマップの代わりにを使用するだけではいけませんか？それは...から始まる列挙型にのみ好ましいものになります...何、2 ^ 10の値？おそらくもっと。

— einpoklum 2018年

@einpoklum実行時に要素の数を確認できればすばらしいでしょうenum。残念ながらできません。そして、マップの要点は名前と値を関連付けることだけであり、これstd::mapは良いことです。

— PaperBirdMaster 2018年

@Paula_plus_plus：initialize()引数の数が列挙値の数である関数をすでに呼び出しているので、コンパイル時に値の数がわかります。実行時にのみ既知であるのは、印刷するように要求される特定の値だけです。また、その数がわからない場合でも、ほとんどすべての現実的なケースでは、std :: vectorはstd :: mapよりも高速です。

— einpoklum 2018年

@einpoklumそれは本当にとても良い点です、私はそれについて考えます、ありがとう！心配しているのstd::arrayは、キーと値のコンテナではないため、findメソッドがないことだけです。とにかく考えてみます。

— PaperBirdMaster 2018年

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 ++要素を使用しませんが、多くの労力とメンテナンスなしで多くのコードを生成するために使用できます。

— エフェリオン
ソース

3

別のファイルは必要ありません。これは本質的にxマクロです。

— HolyBlackCat

@HolyBlackCatソリューションをいくつかのファイルに分割した場合は、列挙値をさまざまな目的に再利用できます

— eferion

値リストをヘッダーの列挙型定義と一緒に単一のマクロに入れれば、同じことができると私はあなたに言っています。

— HolyBlackCat

@HolyBlackCatはい私はあなたを理解していますが、私はこの解決策を好みます。一方、この解決策はclangソースコードで見つけることができるので、問題を解決するための良い方法だと思います

— eferion

けっこうだ。それは確かにいくつかの用途があるので、私は推測してこれに反対票を投じるべきではありませんでした。（ダミーの編集を

— 許してください

6

私は数日前に同じ問題を抱えていました。奇妙なマクロマジックがないとC ++ソリューションを見つけることができなかったので、CMakeコードジェネレーターを作成することにしました。簡単なスイッチケースステートメントを生成を作成する。

使用法：

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>";
   }
}
}

更新：

スクリプトはスコープ付き列挙型（enum class | struct）もサポートするようになり、よく使用する他のいくつかのスクリプトを使用して別のリポジトリに移動しました。https：//github.com/mensinda/cmakeBuildTools

— 濃い
ソース

うわー！非常に独創的で革新的なアイデア:-) constexprとnoexceptバージョンを提供するためにジェネレーターをアップグレードする勇気があることを願っています;-)私もGitHubプロジェクトを開始しました ;-)乾杯

— olibre

1

ジェネレーターを更新しました。関数は常にconstexprおよびenumになります。<type>がサポートされるようになりました。星をありがとう:)

— Mense

リンクが壊れています... -.-

— yeoman

リンクが修正されました。

— メンス

4

列挙型を生成するだけです。そのためのジェネレーターの作成は、約5分の作業です。

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()

— ヨーマン
ソース

1

2つの言語でジェネレータを共有していただきありがとうございます:-)しかし、コンパイル時に生成する方法について何か考えはありますか？たとえば、入力データが変更されたときにC ++で生成されたコードを更新するために、CMakeステートメントを使用してジェネレーターを変換することを想像できますか？私の夢は、C ++コンパイラーに、コンパイル時にメタプログラミング（variadic template classおよびconstexpr関数）を使用して列挙型を生成させることです。

— olibre 2016年

Otoh、カスタムcmakeコマンドを追加するのが面倒な場合は、IDEを自動化するか、gereratorを手動で呼び出して、出力をソース管理に含めることができます。あまり多くない限り、とにかくソース管理でコードを生成することは良い考えであり、人々は手動での変更を想定していないことを理解しています。奇妙なものをデバッグしていて、ジェネレーターへの最近の変更が何かを壊したかもしれないという疑いを持っています:)

— yeoman

コンパイル時に物事を生成することについては、構文が非常にクリーンで簡単なので、LISPではそれはとても簡単です。それは動的に型付けされるという事実によって助けられます。それは多くの構文なしで簡潔で読みやすくすることを可能にします。C ++のLISPマクロに相当するものは、生成しようとしているもののASTを記述するための非常に複雑な方法を必要とします。そしてC ++のASTは決して美しくありません:(

— yeoman

cmakeの代わりにMakeで直接、それは非常に簡単です。findを使用して各.enumファイルの.hおよび.cppターゲットを生成し、これらのターゲットを前述のenum defsに依存させるだけで、.enum defファイルが変更されると、それらは自動的に再生成されます。cmakeは、この種の魔法でいっぱいなので、おそらくはるかに簡単ですが、私は定期的にMake、ant、gradleを使用していますが、Maven、cmake、およびgruntの知識は限られています:)

— yeoman

あなたの答えをありがとう:-)ほとんどのC ++開発者は、ジェネレーターがC ++コード内enum class Hallo{ First=5, Second=6, Third=7, Fourth=8};または数行で列挙型を直接検出できるかどうかを評価すると思います:-D enumC ++内でを検出するためにジェネレーターを適応できると思いますか？ファイル？のようなタグが検出された場合にのみコードを生成するのが最善/*<Generate enum to string here>*/です。次に、ジェネレーターは対応するC ++生成コードをインプレースで書き込みます（以前に生成されたコードを置き換えます）。^ _ ^素晴らしいジェネレータとは何ですか？乾杯:-)

— olibre 2016年

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
ソース

5

このコードブロックは、メタプログラミングの黒魔術の驚くべき風景を巡るクレイジーな旅です。私は実際に到達したとき安心しましたmain—家、甘い家！

— クエンティン

出力を確認するために、coliruへのリンクを追加しました（いくつかの警告があります。回答内のリンクをクリックしてください）。また、Lib / Usageに分割しました。ものはないnamespace xxxヘッダの場所に移動することができますか？イントロであなたの使用boost/preprocessor.hppを言うことができるので、答えは最新のC ++準拠です。警告を修正し、ソースコードを少しきれいにして品質を向上させてください。

— olibre 2015

@olibre：それは私たちのライブラリの5つの異なるヘッダーからのコピーパスタです。enum_castは別のより一般的な部分からのものですが、マクロ内のdo_enum_castが何のためにあるのかを確認するためにも追加しようと思いました。警告は、私main<tab>が使用していない引数を含むvim からのものです。私はこのコードを本当にきれいにすることができるとは思わない、それは何ができるかを示すためだけであり、すべきではない;）そしてここでそれを変更すると、私がもう本番で使用するコードではありません...それはそれらの壊れやすいものの1つですそれが機能したら、誰も予測できない方法で崩壊する可能性があるため、触らない方がよいでしょう。

— PlasmaHH 2015

よし、プラズマ、これは概念実証として見ることができると思う。ただし、マクロのオーバーヘッドが多すぎて投票できません。それにもかかわらず、共有してくれてありがとう。乾杯

— olibre

こんにちはプラズマ。私は、深いソースコードのクリーンアップを実行し、コンパイルと実行出力によって完了しました。編集内容を確認してください。これで大丈夫だと思います。答えはもっと価値がありますか？ただし、マクロのオーバーヘッドは依然として恐ろしいものです。良い一日を。:-)乾杯

— olibre

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

編集：カスタムEnumをクラス内で使用できるようにソリューションを作り直しました。

— FKaria
ソース

興味深い答えをありがとうございます。クラス内でマクロを使用するには、提案をやり直してください。coliru.stacked-crooked.com/a/00d362eba836d04bを参照してください。さらに、可能な場合はキーワードconstexprとnoexeptキーワードを使用してください。乾杯:-)

— olibre 2016年

質問はこの必要条件を明記していませんでした。

— FKaria 2016年

質問が更新されました（例を参照）。その他の2つの要件：（1）列挙型のサポートタイプ、および（2）値はシーケンス0、1、2と異なる場合があります

— olibre

クラス内で使用できるようにソリューションを作り直しました。値を0、1、2、..と異なるようにする方法はまだわかりません。

— FKaria '20年

こんにちはFKaria。リワークありがとうございます。同じクラス内のいくつかの列挙型をサポートし、enum class X : Type形式もサポートするために、いくつかの変更を行いました。私の貢献を確認してください：coliru.stacked-crooked.com/a/b02db9190d3491a3私の変更についてどう思いますか？列挙型内で設定された値をサポートするアイデアはありますか？enum E{A=3, B=6, C=A-B};乾杯の例

— olibre 2016年

2

この要点は、C ++可変テンプレートに基づく簡単なマッピングを提供します。

これは、要点からの型ベースのマップの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

— ろくでなし
ソース

1

非常に興味深いメタプログラミング方法。（Gistリンクに依存せずに）自律的になるように答えを少し簡略化しようとしました。簡潔で理解できるようにするために、私はようやくあなたの答えをたくさん編集しました。私の変更に同意しますか？乾杯;-)

— olibre 2017年

2

この問題と、適切な方法で型を文字列に変換する問題に長い間不満を感じていました。しかし、最後の問題については、標準のC ++で変数の型を出力することはできますか？で説明されている解決策に驚きました。、のアイデアを使用して、C ++の型名をconstexprの方法で取得できますか？。この手法を使用して、列挙値を文字列として取得するための類似の関数を構築できます。

#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でのみテストされていますが、整数定数を少し操作することで他のコンパイラーに適合させることができます。もちろん、それでも内部でマクロを使用しますが、少なくとも1つは列挙型実装へのアクセスを必要としません。

— イグナス
ソース

これはg ++ 6.3.0およびC ++ 14では失敗します。

— einpoklum 2018年

enumをマクロでラップせずに通常どおりに宣言できるので興味深い。コンパイラ依存関係と魔法の定数は好きではありませんが。

— zett42 2018

2

私は@antronからアイデアを取り入れ、別の方法で実装しました：真の列挙型クラスの生成。

この実装は、元の質問にリストされているすべての要件を満たしていますが、現在のところ、実際の制限は1つだけです。ません。列挙値が指定されていないか、または指定されている場合は、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

Plsは、これが有用かどうか、そしてそれをさらに改善する方法を教えてくれました。

#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); \
    }

— ユーリ・フィンケルシュタイン
ソース

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クラスは、enum初期化子の値を消費してから折りたたむ-enumデータの純粋なリストを残すように設計されています。

利点

c++のような構文
との両方enumで同じように機能しますenum class（*ほぼ）
のために働く enum任意の数値基本となるタイプの種類
のために働く enum、自動明示的、断片化初期値の種類
大量の名前変更に対応（インテリセンスリンクは保持されます）
5つのプリプロセッサシンボルのみ（3つはグローバル）

* とは対照的にenums、enum class同じ列挙型からの他の値を参照型の完全修飾された値が必要です

不利益

.h/.cppクエリ可能ごとに個別のペアが必要enum
複雑macroでinclude魔法に依存
マイナーな構文エラーは、はるかに大きなエラーに爆発します
列挙型classまたはnamespaceスコープ付き列挙型の定義は重要です
コンパイル時の初期化なし

名前空間スコープの列挙型を宣言するには、まず列挙型をその名前空間スコープ内で前方宣言し、次にグローバル名前空間で定義する必要があります。さらに、同じ列挙型の値を使用する列挙型初期化子は、それらの値を完全に修飾する必要があります。

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

— ジェイソン・リム
ソース

2

このアプローチが他の回答の1つですでにカバーされているかどうかはわかりません（実際にはカバーされています。以下を参照してください）。私は何度も問題に遭遇し、難読化されたマクロやサードパーティのライブラリを使用しない解決策を見つけませんでした。そのため、独自の難読化されたマクロバージョンを作成することにしました。

有効にしたいのは

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"

ライブデモ

基礎となるタイプの選択はまだ含めていないことに注意してください。これまでは必要ありませんでしたが、コードを変更してそれを有効にするのは簡単です。

これを書いて初めて、私はそれがエフェリオンの回答にかなり似ていることに気づきました。たぶん私は以前にそれを読んだかもしれませんし、おそらくそれがインスピレーションの主な情報源だったかもしれません。私は自分で書くまでXマクロの理解に常に失敗していました;）

— idclev 463035818
ソース

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;

これは「赤1 2」を出力します。<<をオーバーロードして青い出力を文字列にすることもできます（あいまいさを引き起こす可能性があるため不可能です）が、自動的にColorに変換されないため、Color :: GREENでは機能しません。

暗黙的にEnumに変換する（暗黙的にintまたは指定された型に変換する）ことの目的は、次のことができるようにすることです。

Color color;
switch (color) ...

これは機能しますが、この機能も機能することを意味します。

int i = color;

enumクラスではコンパイルできません。列挙型と整数を取る2つの関数をオーバーロードするか、暗黙的な変換を削除する場合は注意が必要です...

別のソリューションでは、実際の列挙型クラスと静的メンバーを使用する必要があります。

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;
};

— パット笑
ソース

これは非常に興味深いものです:-)ただし、現在のバージョンでは、手動で作成する必要がありますcase Enum::RED: return "red";。問題は、コンパイラーによる（コンパイル時の）自動化に関するものです。質問のアイデアは、ものを更新する必要がなく、列挙値のみを変更または追加することですtoString()。見える？ありがとう

— olibre

1

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
ソース

マレム、あなたの革新的なアイデアをありがとう。読みやすさを向上させるために、回答を編集しました。私の変更を気に入っていただければ幸いです。引き続き回答を改善してください：（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 2017

私はこのアプローチが本当に好きです。本当に短くてわかりやすい。

— アントンホルムベルク2018年

1

編集：新しいバージョンについては以下を確認してください

上で述べたように、N4113はこの問題の最終的な解決策ですが、それが出るのを1年以上待たなければなりません。

一方、そのような機能が必要な場合は、「単純な」テンプレートといくつかのプリプロセッサの魔法に頼る必要があります。

列挙子

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に設定されます。
（誰かが標準で^^ this behaviour ^^が言及されている場所を指摘してもらえますか？）
プリプロセッサマジックは、列挙子の宣言を自動化します。

短所

これは真の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
ソース

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[]ます。

このような場合、ライブラリは1つenumだけを作成するように制限されています。これは、たとえば次のような戻り値に最適です。

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

MSG_CODE ret = foo();

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

この設計のもう1つの点は、メッセージ定義をさまざまなファイルで管理できることです。

私はこの質問の解決策がはるかに良く見えることに気づきました。

— マッドウィン
ソース

こんにちはマドウィン。あなたのアイデアをありがとう。しかし、それはどのように機能しますか？オーバーヘッドとは何ですか？（オーバーヘッドはゼロですか、それとも余分なデータが作成されますか？）あなたの命題は問題ないようですが、残念ながら、DEF_MSG各enum値に対して1つのステートメントを使用/更新/維持する必要があります：-/そして、これが理想的に私たちがやめたいことです... Cheers

— olibre

@olibre、返信ありがとうございます。更新された回答を確認してください。文字列にアクセスするために関数呼び出しが必要な場合を除いて、ここにはオーバーヘッドはありません。DEF_MSGなりenum、それはいくつかの制限があるが、密接にメッセージとペアを。

— Madwyn、2015年

回答に追加の説明をありがとうございます:-)あなたのlibは問題ありませんが、複数の列挙型には使用できません：-/ enum class（C ++ 11）のサポートはどうですか？実行時constexprに制限するために使用できます_g_messages。メタプログラミング（{enum-type、enum-value}を伝達するタイプ）またはテンプレート変数（C ++ 14）を使用して、複数のenumタイプ（回避_g_messages）をサポートします。あなたのlibは（まだ？）C ++ 11/14/17の要件に適合しないと思います。どう思いますか？乾杯;-)

— olibre 2015年

1

フォローアップありがとうございます。今日は新しいことを学びました！enumクラスとテンプレート変数は見栄えがします。私の答えは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マクロが「列挙型クラス」と「列挙型リフレクション関数」を持つヘルパークラスを生成します。

間違いを減らすために、一度にすべてが1つのENUM_MAKEだけで定義されます。

このコードの利点は、自動的に反映され、マクロコードをよく見ると、わかりやすいコードです。'enum to string'、 'string to enum'のパフォーマンスはどちらもアルゴリズムO（1）です。

欠点は、最初の使用時、列挙型選択の文字列ベクトルとマップのヘルパークラスが初期化されるときです。ただし、必要に応じて、事前初期化も行います。–

— desperado_98
ソース

このコードは質問に答えることがありますが、他の人を紹介せずに問題を解決する方法とそれを使用する理由を説明する方が良いでしょう。コードのみの回答は、長期的には役に立ちません。

— JAL

やあみんな、ごめんなさい、英語が上手く話せません。

— desperado_98

自動的にENUM_MAKEマクロが「列挙型クラス」と「列挙型リフレクション関数」を持つヘルパークラスを生成します。/間違いを減らすために、一度にすべてが1つのENUM_MAKEだけで定義されます。このコードの利点は、自動的に反映され、マクロコードをよく見ると、わかりやすいコードです。'enum to string'、 'string to enum'のパフォーマンスはどちらもアルゴリズムO（1）です。欠点は、最初の使用時、列挙型選択の文字列ベクトルとマップのヘルパークラスが初期化されるときです。ただし、必要に応じて、事前初期化も行います。

— desperado_98

こんにちはdesperado_98。ご協力いただき、ありがとうございます。回答を編集して、コメントコンテンツを挿入してください。いくつかのメタプログラミングトリックおよびを使用すると、コンパイラはコンパイル時にサンプルを計算できますconstexpr。私は、関数を意味toName()し、toType()コンパイル時ではなく、実行（実行時）の間に評価することができます。回答にはC ++ 11/14/17スタイルを採用してください。乾杯;-)

— olibre 2015年

さらに：マクロはと互換性があり enum class MyEnum : short { A, B, C };ますか？

— olibre 2015年

0

私の解決策はマクロを使用しないことです。

利点：

あなたはあなたが何をしているかを正確に見る
アクセスはハッシュマップを使用するため、多くの重要な列挙型に適しています
順序や連続しない値を考慮する必要はありません
enumからstringへの変換とstringからenumへの変換の両方。一方、追加されたenum値は、1つの追加の場所にのみ追加する必要があります。

欠点：

すべての列挙値をテキストとして複製する必要があります
ハッシュマップでのアクセスは文字列の大文字小文字を考慮する必要があります
値の追加が面倒な場合のメンテナンス-enumと直接変換マップの両方を追加する必要があります

そう... 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];

— ミア・シャニ
ソース

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
ソース

1

メモリ使用量を減らすために、メンバーconst std::string textを単にで置き換えることができますtheStrings[v]。ただし、問題は、C ++ 11 / C ++ 14 / C ++ 17 / C ++ 20の機能について、そのようなクラスを手動で記述しなくても済むようにすることです：-/

— olibre

0

私の答えはこちらです。

enum値の名前とこれらのインデックスを文字列の両端キューとして同時に取得できます。

この方法では、コピー、貼り付け、編集はほとんど必要ありません。

取得した結果は、enumクラス型の値が必要なときにsize_tからenumクラス型への型キャストが必要ですが、それはenumクラスを処理するための非常に移植性があり強力な方法だと思います。

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
ソース

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"

— ニック
ソース

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

— タルモピカロ
ソース

-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
ソース

5

1）さらに複製が作成されます2）ストリームを使用する必要があります

— Karoly Horvath

6

-1申し訳ありませんが、@ dau_samaですが、これらすべての列挙型から文字列の繰り返し質問への目的は、列挙型/文字列マッピングのメンテナンスを回避することです。回答が目的に合わないと思われる場合は、回答の削除をご検討ください。次の回答で頑張ってください;）乾杯

— olibre

-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
ソース

4

これはどうやって質問に答えますか？質問には、最新のC ++で列挙型を文字列に変換することが明記されています。

— Michael Choi

1

@MichaelChoi —ありますが、適切なツールをジョブに使用するという問題もあります。C++がチューリング完全であり、したがってすべての解決可能な問題を解決できるからといって、ソリューションが高速、保守可能、または効率的であるとは限りません。適切な/望ましい機能を持つ言語を使用し、それをエクスポートすることは有効なソリューションです。

— Shark8

3

質問の最初の文で、「この質問は新しいC ++機能の使用に関するものです」。次に、「C ++ 11、C ++ 14、またはC ++ 17の新機能を使用してエレガントな方法を見つけることはできませんでした」。著者は明らかにC ++ソリューションを探していました。あなたはエイダで解決策を与えたので、あなたは質問に答えませんでした。おそらく質問の範囲になかった何かを解決するために、まったく異なる依存関係を組み込むことを提案しています。

— Michael Choi

最新のC ++ 11 / C ++ 14 / C ++ 17および将来のC ++ 20の文字列の列挙型

他のすべての同様の質問とは異なり、この質問は新しいC ++機能の使用に関するものです。

多くの回答を読んだ後、私はまだ何も見つかりませんでした：

例

制約

あった方がよい

Magic Enumヘッダーのみのライブラリは、C ++ 17の列挙型（文字列へ、文字列から、反復）の静的リフレクションを提供します。

欠点はどこですか？

説明

コード

編集する

更新：

ライブラリ（単一のヘッダーファイル内にマージ）

使用法

コンパイル（ヘッダーを内に貼り付けますmain.cpp）

出力

コード

説明

利点

不利益

コメント

編集：新しいバージョンについては以下を確認してください

列挙子

使用法

簡単な説明

短所

代替ソリューション

エラッタ

回避策

使用法

実際の実装と使用

クイックリファレンス

使用法：

コンパイル（ヘッダーを内に貼り付けます`main.cpp`）