C ++列挙型を文字列に変換する簡単な方法はありますか？

https://stackoverflow.com/questions/201593

03-07-2019
|

質問

いくつかの名前付き列挙型があるとします：

enum MyEnum {
      FOO,
      BAR = 0x50
};

Googleで検索したのは、プロジェクトのすべてのヘッダーをスキャンし、列挙ごとに1つの関数を持つヘッダーを生成するスクリプト（任意の言語）です。

char* enum_to_string(MyEnum t);

そして次のような実装：

char* enum_to_string(MyEnum t){
      switch(t){
         case FOO:
            return "FOO";
         case BAR:
            return "BAR";
         default:
            return "INVALID ENUM";
      }
 }

実際には、型定義された列挙型と名前のないCスタイルの列挙型があります。誰かこれを知っていますか？

編集：ソリューションは、生成された関数を除き、ソースを変更しないでください。列挙型はAPIに含まれているため、これまでに提案されたソリューションを使用することは選択肢ではありません。

解決

GCCXML をご覧ください。

サンプルコードでGCCXMLを実行すると、次が生成されます。

<GCC_XML>
  <Namespace id="_1" name="::" members="_3 " mangled="_Z2::"/>
  <Namespace id="_2" name="std" context="_1" members="" mangled="_Z3std"/>
  <Enumeration id="_3" name="MyEnum" context="_1" location="f0:1" file="f0" line="1">
    <EnumValue name="FOO" init="0"/>
    <EnumValue name="BAR" init="80"/>
  </Enumeration>
  <File id="f0" name="my_enum.h"/>
</GCC_XML>

任意の言語を使用して、EnumerationタグとEnumValueタグを引き出し、目的のコードを生成できます。

他のヒント

Xマクロは最適なソリューションです。例：

#include <iostream>

enum Colours {
#   define X(a) a,
#   include "colours.def"
#   undef X
    ColoursCount
};

char const* const colours_str[] = {
#   define X(a) #a,
#   include "colours.def"
#   undef X
    0
};

std::ostream& operator<<(std::ostream& os, enum Colours c)
{
    if (c >= ColoursCount || c < 0) return os << "???";
    return os << colours_str[c];
}

int main()
{
    std::cout << Red << Blue << Green << Cyan << Yellow << Magenta << std::endl;
}

colours.def：

X(Red)
X(Green)
X(Blue)
X(Cyan)
X(Yellow)
X(Magenta)

ただし、通常は次の方法を好むため、文字列を少し調整することができます。

#define X(a, b) a,
#define X(a, b) b,

X(Red, "red")
X(Green, "green")
// etc.

@hydroo：余分なファイルなし：

#define SOME_ENUM(DO) \
    DO(Foo) \
    DO(Bar) \
    DO(Baz)

#define MAKE_ENUM(VAR) VAR,
enum MetaSyntacticVariable{
    SOME_ENUM(MAKE_ENUM)
};

#define MAKE_STRINGS(VAR) #VAR,
const char* const MetaSyntacticVariableNames[] = {
    SOME_ENUM(MAKE_STRINGS)
};

私がしがちなのは、enum値と同じ順序と位置にある名前でC配列を作成することです。

eg。

enum colours { red, green, blue };
const char *colour_names[] = { "red", "green", "blue" };

その後、人間が読み取れる値が必要な場所で配列を使用できます。

colours mycolour = red;
cout << "the colour is" << colour_names[mycolour];

文字列化演算子（プリプロセッサリファレンスの＃を参照）を少し試してみると、状況によっては必要なことを行うことができます。例：

#define printword(XX) cout << #XX;
printword(red);

<！> quot; red <！> quot;を印刷します。標準出力に。残念ながら、変数に対しては機能しません（変数名が出力されるため）

これを完全に乾燥した方法で行う非常にシンプルなマクロを使用しています。これには、可変長マクロといくつかの単純な解析マジックが含まれます。ここに行きます：

#define AWESOME_MAKE_ENUM(name, ...) enum class name { __VA_ARGS__, __COUNT}; \
inline std::ostream& operator<<(std::ostream& os, name value) { \
std::string enumName = #name; \
std::string str = #__VA_ARGS__; \
int len = str.length(); \
std::vector<std::string> strings; \
std::ostringstream temp; \
for(int i = 0; i < len; i ++) { \
if(isspace(str[i])) continue; \
        else if(str[i] == ',') { \
        strings.push_back(temp.str()); \
        temp.str(std::string());\
        } \
        else temp<< str[i]; \
} \
strings.push_back(temp.str()); \
os << enumName << "::" << strings[static_cast<int>(value)]; \
return os;}

コードでこれを使用するには、次を実行します。

AWESOME_MAKE_ENUM(Animal,
    DOG,
    CAT,
    HORSE
);

QTはそれを引き出すことができます（メタオブジェクトコンパイラのおかげです）：リンク

今日このホイールを再発明し、共有したいと思いました。

この実装では、定数を定義するコードを変更する必要はありません列挙、#define s、または整数に変換される他のもの-私の場合はシンボルを定義しました他のシンボルに関して。また、スパース値でもうまく機能します。同じ値に複数の名前を付けることもでき、常に最初の名前を返します。唯一の欠点は、定数のテーブルを作成する必要があることです。これは、たとえば新しい定数が追加されると古くなる可能性があります。

struct IdAndName { int id; const char * name; bool operator<(const IdAndName &rhs) const { return id < rhs.id; } }; #define ID_AND_NAME(x) { x, #x } const char * IdToName(int id, IdAndName *table_begin, IdAndName *table_end) { if ((table_end - table_begin) > 1 && table_begin[0].id > table_begin[1].id) std::stable_sort(table_begin, table_end); IdAndName searchee = { id, NULL }; IdAndName *p = std::lower_bound(table_begin, table_end, searchee); return (p == table_end || p->id != id) ? NULL : p->name; } template<int N> const char * IdToName(int id, IdAndName (&table)[N]) { return IdToName(id, &table[0], &table[N]); }

使用方法の例：

static IdAndName WindowsErrorTable[] = { ID_AND_NAME(INT_MAX), // flag value to indicate unsorted table ID_AND_NAME(NO_ERROR), ID_AND_NAME(ERROR_INVALID_FUNCTION), ID_AND_NAME(ERROR_FILE_NOT_FOUND), ID_AND_NAME(ERROR_PATH_NOT_FOUND), ID_AND_NAME(ERROR_TOO_MANY_OPEN_FILES), ID_AND_NAME(ERROR_ACCESS_DENIED), ID_AND_NAME(ERROR_INVALID_HANDLE), ID_AND_NAME(ERROR_ARENA_TRASHED), ID_AND_NAME(ERROR_NOT_ENOUGH_MEMORY), ID_AND_NAME(ERROR_INVALID_BLOCK), ID_AND_NAME(ERROR_BAD_ENVIRONMENT), ID_AND_NAME(ERROR_BAD_FORMAT), ID_AND_NAME(ERROR_INVALID_ACCESS), ID_AND_NAME(ERROR_INVALID_DATA), ID_AND_NAME(ERROR_INVALID_DRIVE), ID_AND_NAME(ERROR_CURRENT_DIRECTORY), ID_AND_NAME(ERROR_NOT_SAME_DEVICE), ID_AND_NAME(ERROR_NO_MORE_FILES) }; const char * error_name = IdToName(GetLastError(), WindowsErrorTable);

IdToName関数はstd::lower_boundに依存してクイック検索を実行しますが、これにはテーブルのソートが必要です。テーブルの最初の2つのエントリの順序が狂っている場合、関数は自動的にソートします。

編集：コメントにより、同じ原則を使用する別の方法について考えさせられました。マクロは、大きなswitchステートメントの生成を単純化します。

#define ID_AND_NAME(x) case x: return #x const char * WindowsErrorToName(int id) { switch(id) { ID_AND_NAME(ERROR_INVALID_FUNCTION); ID_AND_NAME(ERROR_FILE_NOT_FOUND); ID_AND_NAME(ERROR_PATH_NOT_FOUND); ID_AND_NAME(ERROR_TOO_MANY_OPEN_FILES); ID_AND_NAME(ERROR_ACCESS_DENIED); ID_AND_NAME(ERROR_INVALID_HANDLE); ID_AND_NAME(ERROR_ARENA_TRASHED); ID_AND_NAME(ERROR_NOT_ENOUGH_MEMORY); ID_AND_NAME(ERROR_INVALID_BLOCK); ID_AND_NAME(ERROR_BAD_ENVIRONMENT); ID_AND_NAME(ERROR_BAD_FORMAT); ID_AND_NAME(ERROR_INVALID_ACCESS); ID_AND_NAME(ERROR_INVALID_DATA); ID_AND_NAME(ERROR_INVALID_DRIVE); ID_AND_NAME(ERROR_CURRENT_DIRECTORY); ID_AND_NAME(ERROR_NOT_SAME_DEVICE); ID_AND_NAME(ERROR_NO_MORE_FILES); default: return NULL; } }

#define stringify( name ) # name enum MyEnum { ENUMVAL1 }; ...stuff... stringify(EnumName::ENUMVAL1); // Returns MyEnum::ENUMVAL1

この方法の詳細

新人向けのプリプロセッサディレクティブトリック

多くの方法を見るのは興味深い。ここに私がずっと前に使用したものがあります：

myenummap.hファイル内：

#include <map> #include <string> enum test{ one, two, three, five=5, six, seven }; struct mymap : std::map<unsigned int, std::string> { mymap() { this->operator[]( one ) = "ONE"; this->operator[]( two ) = "TWO"; this->operator[]( three ) = "THREE"; this->operator[]( five ) = "FIVE"; this->operator[]( six ) = "SIX"; this->operator[]( seven ) = "SEVEN"; }; ~mymap(){}; };

main.cpp
内
#include "myenummap.h" ... mymap nummap; std::cout<< nummap[ one ] << std::endl;

constではありませんが、便利です。

C ++ 11機能を使用する別の方法を次に示します。これはconstであり、STLコンテナを継承せず、少し整頓されています：

#include <vector> #include <string> #include <algorithm> #include <iostream> //These stay together and must be modified together enum test{ one, two, three, five=5, six, seven }; std::string enum_to_str(test const& e) { typedef std::pair<int,std::string> mapping; auto m = [](test const& e,std::string const& s){return mapping(static_cast<int>(e),s);}; std::vector<mapping> const nummap = { m(one,"one"), m(two,"two"), m(three,"three"), m(five,"five"), m(six,"six"), m(seven,"seven"), }; for(auto i : nummap) { if(i.first==static_cast<int>(e)) { return i.second; } } return ""; } int main() { // std::cout<< enum_to_str( 46 ) << std::endl; //compilation will fail std::cout<< "Invalid enum to string : [" << enum_to_str( test(46) ) << "]"<<std::endl; //returns an empty string std::cout<< "Enumval five to string : ["<< enum_to_str( five ) << "] "<< std::endl; //works return 0; }

これはC ++ 11で実行できます

#include <map> enum MyEnum { AA, BB, CC, DD }; static std::map< MyEnum, const char * > info = { {AA, "This is an apple"}, {BB, "This is a book"}, {CC, "This is a coffee"}, {DD, "This is a door"} }; void main() { std::cout << info[AA] << endl << info[BB] << endl << info[CC] << endl << info[DD] << endl; }

#include <stdarg.h> #include <algorithm> #include <string> #include <vector> #include <sstream> #include <map> #define SMART_ENUM(EnumName, ...) \ class EnumName \ { \ private: \ static std::map<int, std::string> nameMap; \ public: \ enum {__VA_ARGS__}; \ private: \ static std::map<int, std::string> initMap() \ { \ using namespace std; \ \ int val = 0; \ string buf_1, buf_2, str = #__VA_ARGS__; \ replace(str.begin(), str.end(), '=', ' '); \ stringstream stream(str); \ vector<string> strings; \ while (getline(stream, buf_1, ',')) \ strings.push_back(buf_1); \ map<int, string> tmp; \ for(vector<string>::iterator it = strings.begin(); \ it != strings.end(); \ ++it) \ { \ buf_1.clear(); buf_2.clear(); \ stringstream localStream(*it); \ localStream>> buf_1 >> buf_2; \ if(buf_2.size() > 0) \ val = atoi(buf_2.c_str()); \ tmp[val++] = buf_1; \ } \ return tmp; \ } \ public: \ static std::string toString(int aInt) \ { \ return nameMap[aInt]; \ } \ }; \ std::map<int, std::string> \ EnumName::nameMap = EnumName::initMap();

使用法：

SMART_ENUM(MyEnum, ONE=1, TWO, THREE, TEN=10, ELEVEN) cout<<MyEnum::toString(MyEnum::TWO); cout<<MyEnum::toString(10);

別の答え：一部のコンテキストでは、CSV、YAML、またはXMLファイルなどの非コード形式で列挙を定義し、C ++列挙コードとto-stringコードの両方を定義。このアプローチは、アプリケーションで実際的である場合とそうでない場合がありますが、留意する必要があります。

これは、@ user3360260の回答の修正です。次の新機能があります

MyEnum fromString(const string&)サポート

VisualStudio 2012でコンパイル

enumは（const宣言だけでなく）実際のPOD型であるため、変数に割り当てることができます。

C ++を追加<！> quot; range <！> quot; <！> quot; foreach <！> quot;を許可する機能（ベクター形式）。列挙型の繰り返し

使用法：

SMART_ENUM(MyEnum, ONE=1, TWO, THREE, TEN=10, ELEVEN) MyEnum foo = MyEnum::TWO; cout << MyEnum::toString(foo); // static method cout << foo.toString(); // member method cout << MyEnum::toString(MyEnum::TWO); cout << MyEnum::toString(10); MyEnum foo = myEnum::fromString("TWO"); // C++11 iteration over all values for( auto x : MyEnum::allValues() ) { cout << x.toString() << endl; }

コードは次のとおりです

#define SMART_ENUM(EnumName, ...) \ class EnumName \ { \ public: \ EnumName() : value(0) {} \ EnumName(int x) : value(x) {} \ public: \ enum {__VA_ARGS__}; \ private: \ static void initMap(std::map<int, std::string>& tmp) \ { \ using namespace std; \ \ int val = 0; \ string buf_1, buf_2, str = #__VA_ARGS__; \ replace(str.begin(), str.end(), '=', ' '); \ stringstream stream(str); \ vector<string> strings; \ while (getline(stream, buf_1, ',')) \ strings.push_back(buf_1); \ for(vector<string>::iterator it = strings.begin(); \ it != strings.end(); \ ++it) \ { \ buf_1.clear(); buf_2.clear(); \ stringstream localStream(*it); \ localStream>> buf_1 >> buf_2; \ if(buf_2.size() > 0) \ val = atoi(buf_2.c_str()); \ tmp[val++] = buf_1; \ } \ } \ int value; \ public: \ operator int () const { return value; } \ std::string toString(void) const { \ return toString(value); \ } \ static std::string toString(int aInt) \ { \ return nameMap()[aInt]; \ } \ static EnumName fromString(const std::string& s) \ { \ auto it = find_if(nameMap().begin(), nameMap().end(), [s](const std::pair<int,std::string>& p) { \ return p.second == s; \ }); \ if (it == nameMap().end()) { \ /*value not found*/ \ throw EnumName::Exception(); \ } else { \ return EnumName(it->first); \ } \ } \ class Exception : public std::exception {}; \ static std::map<int,std::string>& nameMap() { \ static std::map<int,std::string> nameMap0; \ if (nameMap0.size() ==0) initMap(nameMap0); \ return nameMap0; \ } \ static std::vector<EnumName> allValues() { \ std::vector<EnumName> x{ __VA_ARGS__ }; \ return x; \ } \ bool operator<(const EnumName a) const { return (int)*this < (int)a; } \ };

変換toStringは高速検索であるのに対し、変換fromStringは低速線形検索であることに注意してください。しかし、文字列はとにかく非常に高価です（および関連するファイルIO）。

Sumaのマクロソリューションいいね。ただし、2つの異なるマクロを用意する必要はありません。 C ++は喜んでヘッダーを2回インクルードします。インクルードガードを省略します。

つまり、foobar.hで定義されているだけです

ENUM(Foo, 1) ENUM(Bar, 2)

そして次のように含めます：

#define ENUMFACTORY_ARGUMENT "foobar.h" #include "enumfactory.h"

enumfactory.hは2つの#include ENUMFACTORY_ARGUMENT sを実行します。最初のラウンドでは、スマのDECLARE_ENUMのようにENUMを展開します。 2回目のラウンドでは、ENUMはDEFINE_ENUMのように機能します。

ENUMFACTORY_ARGUMENTに異なる#defineを渡す限り、enumfactory.hを複数回含めることができます

変換関数は、理想的には const char *を返す必要があることに注意してください。

列挙型を個別のヘッダーファイルに入れる余裕がある場合は、おそらくマクロで次のようなことを行うことができます（ああ、これはthisいです）：

#include "enum_def.h" #include "colour.h" #include "enum_conv.h" #include "colour.h"

enum_def.hの場所：

#undef ENUM_START #undef ENUM_ADD #undef ENUM_END #define ENUM_START(NAME) enum NAME { #define ENUM_ADD(NAME, VALUE) NAME = VALUE, #define ENUM_END };

そして、enum_conv.hには以下があります：

#undef ENUM_START #undef ENUM_ADD #undef ENUM_END #define ENUM_START(NAME) const char *##NAME##_to_string(NAME val) { switch (val) { #define ENUM_ADD(NAME, VALUE) case NAME: return #NAME; #define ENUM_END default: return "Invalid value"; } }

そして最後に、colour.hには以下があります：

ENUM_START(colour) ENUM_ADD(red, 0xff0000) ENUM_ADD(green, 0x00ff00) ENUM_ADD(blue, 0x0000ff) ENUM_END

そして、次のように変換関数を使用できます：

printf("%s", colour_to_string(colour::red));

これは見苦しいですが、コードの1か所で列挙型を定義できる唯一の方法です（プリプロセッサレベルで）。したがって、列挙型の変更によるコードのエラーは発生しません。列挙定義と変換関数は常に同期されます。しかし、繰り返しますが、これは見苦しいです：）

これは、マクロで生成される個別の並列列挙型ラッパークラスを使用して行います。いくつかの利点があります：

定義していない列挙型に対して生成できます（例：OSプラットフォームヘッダー列挙型）

範囲チェックをラッパークラスに組み込むことができます

<！> quot; smarter <！> quot;ビットフィールド列挙を使用した書式設定

もちろん、欠点は、フォーマッタークラスで列挙値を複製する必要があり、それらを生成するスクリプトがないことです。ただし、それ以外はかなりうまくいくようです。

マクロとテンプレートを実装するすべてのフレームワークコードを除いて、私のコードベースの列挙型の例を示しますが、アイデアは得られます：

enum EHelpLocation { HELP_LOCATION_UNKNOWN = 0, HELP_LOCAL_FILE = 1, HELP_HTML_ONLINE = 2, }; class CEnumFormatter_EHelpLocation : public CEnumDefaultFormatter< EHelpLocation > { public: static inline CString FormatEnum( EHelpLocation eValue ) { switch ( eValue ) { ON_CASE_VALUE_RETURN_STRING_OF_VALUE( HELP_LOCATION_UNKNOWN ); ON_CASE_VALUE_RETURN_STRING_OF_VALUE( HELP_LOCAL_FILE ); ON_CASE_VALUE_RETURN_STRING_OF_VALUE( HELP_HTML_ONLINE ); default: return FormatAsNumber( eValue ); } } }; DECLARE_RANGE_CHECK_CLASS( EHelpLocation, CRangeInfoSequential< HELP_HTML_ONLINE > ); typedef ESmartEnum< EHelpLocation, HELP_LOCATION_UNKNOWN, CEnumFormatter_EHelpLocation, CRangeInfo_EHelpLocation > SEHelpLocation;

アイデアは、EHelpLocationを使用する代わりに、SEHelpLocationを使用することです。すべてが同じように機能しますが、列挙型変数自体に対して範囲チェックと「Format（）」メソッドを取得します。スタンドアロン値をフォーマットする必要がある場合は、CEnumFormatter_EHelpLocation :: FormatEnum（...）を使用できます。

これが役立つことを願っています。これは、実際に他のクラスを生成するスクリプトに関する元の質問には対応していませんが、この構造が誰かが同じ問題を解決したり、そのようなスクリプトを書いたりするのに役立つことを願っています。

ここに1ファイルのソリューション（@Marcinによるエレガントな回答に基づく：

#include <iostream> #define ENUM_TXT \ X(Red) \ X(Green) \ X(Blue) \ X(Cyan) \ X(Yellow) \ X(Magenta) \ enum Colours { # define X(a) a, ENUM_TXT # undef X ColoursCount }; char const* const colours_str[] = { # define X(a) #a, ENUM_TXT # undef X 0 }; std::ostream& operator<<(std::ostream& os, enum Colours c) { if (c >= ColoursCount || c < 0) return os << "???"; return os << colours_str[c] << std::endl; } int main() { std::cout << Red << Blue << Green << Cyan << Yellow << Magenta << std::endl; }

これはBOOSTを使用した私のソリューションでした：

#include <boost/preprocessor.hpp> #define X_STR_ENUM_TOSTRING_CASE(r, data, elem) \ case elem : return BOOST_PP_STRINGIZE(elem); #define X_ENUM_STR_TOENUM_IF(r, data, elem) \ else if(data == BOOST_PP_STRINGIZE(elem)) return elem; #define STR_ENUM(name, enumerators) \ enum name { \ BOOST_PP_SEQ_ENUM(enumerators) \ }; \ \ inline const QString enumToStr(name v) \ { \ switch (v) \ { \ BOOST_PP_SEQ_FOR_EACH( \ X_STR_ENUM_TOSTRING_CASE, \ name, \ enumerators \ ) \ \ default: \ return "[Unknown " BOOST_PP_STRINGIZE(name) "]"; \ } \ } \ \ template <typename T> \ inline const T strToEnum(QString v); \ \ template <> \ inline const name strToEnum(QString v) \ { \ if(v=="") \ throw std::runtime_error("Empty enum value"); \ \ BOOST_PP_SEQ_FOR_EACH( \ X_ENUM_STR_TOENUM_IF, \ v, \ enumerators \ ) \ \ else \ throw std::runtime_error( \ QString("[Unknown value %1 for enum %2]") \ .arg(v) \ .arg(BOOST_PP_STRINGIZE(name)) \ .toStdString().c_str()); \ }

enumを作成するには、宣言します：

STR_ENUM ( SERVICE_RELOAD, (reload_log) (reload_settings) (reload_qxml_server) )

コンバージョンの場合：

SERVICE_RELOAD serviceReloadEnum = strToEnum<SERVICE_RELOAD>("reload_log"); QString serviceReloadStr = enumToStr(reload_log);

Jasper Bekkersの素晴らしい回答にさらにシンプルな使用法を追加：

一度セットアップする：

#define MAKE_ENUM(VAR) VAR, #define MAKE_STRINGS(VAR) #VAR, #define MAKE_ENUM_AND_STRINGS(source, enumName, enumStringName) \ enum enumName { \ source(MAKE_ENUM) \ };\ const char* const enumStringName[] = { \ source(MAKE_STRINGS) \ };

次に、使用法について：

#define SOME_ENUM(DO) \ DO(Foo) \ DO(Bar) \ DO(Baz) ... MAKE_ENUM_AND_STRINGS(SOME_ENUM, someEnum, someEnumNames)

回答0の問題は、enumバイナリ値が必ずしも0で始まるわけではなく、必ずしも連続していないことです。

これが必要なとき、私は通常：

enum定義をソースにプルする

名前だけを取得するように編集

マクロを実行して、名前を質問のcase句に変更しますが、通常は1行で入力します。case foo：return <！> quot; foo <！> quot ;;

スイッチ、デフォルト、およびその他の構文を追加して有効にします

次のrubyスクリプトは、ヘッダーの解析を試み、必要なソースを元のヘッダーとともに構築します。

#! /usr/bin/env ruby # Let's "parse" the headers # Note that using a regular expression is rather fragile # and may break on some inputs GLOBS = [ "toto/*.h", "tutu/*.h", "tutu/*.hxx" ] enums = {} GLOBS.each { |glob| Dir[glob].each { |header| enums[header] = File.open(header, 'rb') { |f| f.read }.scan(/enum\s+(\w+)\s+\{\s*([^}]+?)\s*\}/m).collect { |enum_name, enum_key_and_values| [ enum_name, enum_key_and_values.split(/\s*,\s*/).collect { |enum_key_and_value| enum_key_and_value.split(/\s*=\s*/).first } ] } } } # Now we build a .h and .cpp alongside the parsed headers # using the template engine provided with ruby require 'erb' template_h = ERB.new <<-EOS #ifndef <%= enum_name %>_to_string_h_ #define <%= enum_name %>_to_string_h_ 1 #include "<%= header %>" char* enum_to_string(<%= enum_name %> e); #endif EOS template_cpp = ERB.new <<-EOS #include "<%= enum_name %>_to_string.h" char* enum_to_string(<%= enum_name %> e) { switch (e) {<% enum_keys.each do |enum_key| %> case <%= enum_key %>: return "<%= enum_key %>";<% end %> default: return "INVALID <%= enum_name %> VALUE"; } } EOS enums.each { |header, enum_name_and_keys| enum_name_and_keys.each { |enum_name, enum_keys| File.open("#{File.dirname(header)}/#{enum_name}_to_string.h", 'wb') { |built_h| built_h.write(template_h.result(binding)) } File.open("#{File.dirname(header)}/#{enum_name}_to_string.cpp", 'wb') { |built_cpp| built_cpp.write(template_cpp.result(binding)) } } }

正規表現を使用すると、この<！> quot; parser <！> quot;非常に壊れやすいため、特定のヘッダーを適切に処理できない場合があります。

MyEnumおよびMyEnum2列挙型の定義を含むtoto / a.hヘッダーがあるとします。スクリプトはビルドします：

toto/MyEnum_to_string.h toto/MyEnum_to_string.cpp toto/MyEnum2_to_string.h toto/MyEnum2_to_string.cpp

より堅牢なソリューションは次のとおりです。

列挙とその操作を定義するすべてのソースを別のソースから構築します。これは、C / C ++よりもはるかに簡単に解析できるXML / YML / whateverファイルで列挙型を定義することを意味します。

Avdiが提案したような実際のコンパイラを使用します。

テンプレートの有無にかかわらずプリプロセッサマクロを使用します。

未リリースのソフトウェアですが、フランク・ラウブのBOOST_ENUMがこの法案に収まるようです。私がそれについて気に入っている部分は、ほとんどのマクロベースの列挙型では通常できないクラスのスコープ内で列挙型を定義できることです。 Boost Vaultの http://www.boostpro.com/vault/index.php?action=downloadfile <！> amp; filename = enum_rev4.6.zip <！> amp; directory = <！>アンプ; 2006年以降、開発が行われていないため、新しいBoostリリースでどれだけうまくコンパイルできるかわかりません。使用例については、libs / testをご覧ください。

誰かが便利だと思ったら、これを投稿したい。

私の場合、単一のToString()ファイルから単一のC ++ 11列挙型のFromString()および.hpp関数を生成するだけです。

列挙項目を含むヘッダーファイルを解析し、新しい.cppファイルに関数を生成するPythonスクリプトを作成しました。

このスクリプトを execute_process でCMakeLists.txtに追加できます、またはVisual Studioのビルド前イベントとして。 python generate_enum_strings.py ErrorCode.hppファイルは自動的に生成されます。新しい列挙項目が追加されるたびに手動で更新する必要はありません。

generate_enum_strings.py

# This script is used to generate strings from C++ enums import re import sys import os fileName = sys.argv[1] enumName = os.path.basename(os.path.splitext(fileName)[0]) with open(fileName, 'r') as f: content = f.read().replace('\n', '') searchResult = re.search('enum(.*)\{(.*?)\};', content) tokens = searchResult.group(2) tokens = tokens.split(',') tokens = map(str.strip, tokens) tokens = map(lambda token: re.search('([a-zA-Z0-9_]*)', token).group(1), tokens) textOut = '' textOut += '\n#include "' + enumName + '.hpp"\n\n' textOut += 'namespace myns\n' textOut += '{\n' textOut += ' std::string ToString(ErrorCode errorCode)\n' textOut += ' {\n' textOut += ' switch (errorCode)\n' textOut += ' {\n' for token in tokens: textOut += ' case ' + enumName + '::' + token + ':\n' textOut += ' return "' + token + '";\n' textOut += ' default:\n' textOut += ' return "Last";\n' textOut += ' }\n' textOut += ' }\n' textOut += '\n' textOut += ' ' + enumName + ' FromString(const std::string &errorCode)\n' textOut += ' {\n' textOut += ' if ("' + tokens[0] + '" == errorCode)\n' textOut += ' {\n' textOut += ' return ' + enumName + '::' + tokens[0] + ';\n' textOut += ' }\n' for token in tokens[1:]: textOut += ' else if("' + token + '" == errorCode)\n' textOut += ' {\n' textOut += ' return ' + enumName + '::' + token + ';\n' textOut += ' }\n' textOut += '\n' textOut += ' return ' + enumName + '::Last;\n' textOut += ' }\n' textOut += '}\n' fileOut = open(enumName + '.cpp', 'w') fileOut.write(textOut)

例：

ErrorCode.hpp

#pragma once #include <string> #include <cstdint> namespace myns { enum class ErrorCode : uint32_t { OK = 0, OutOfSpace, ConnectionFailure, InvalidJson, DatabaseFailure, HttpError, FileSystemError, FailedToEncrypt, FailedToDecrypt, EndOfFile, FailedToOpenFileForRead, FailedToOpenFileForWrite, FailedToLaunchProcess, Last }; std::string ToString(ErrorCode errorCode); ErrorCode FromString(const std::string &errorCode); }

実行<=>

結果：

ErrorCode.cpp

#include "ErrorCode.hpp" namespace myns { std::string ToString(ErrorCode errorCode) { switch (errorCode) { case ErrorCode::OK: return "OK"; case ErrorCode::OutOfSpace: return "OutOfSpace"; case ErrorCode::ConnectionFailure: return "ConnectionFailure"; case ErrorCode::InvalidJson: return "InvalidJson"; case ErrorCode::DatabaseFailure: return "DatabaseFailure"; case ErrorCode::HttpError: return "HttpError"; case ErrorCode::FileSystemError: return "FileSystemError"; case ErrorCode::FailedToEncrypt: return "FailedToEncrypt"; case ErrorCode::FailedToDecrypt: return "FailedToDecrypt"; case ErrorCode::EndOfFile: return "EndOfFile"; case ErrorCode::FailedToOpenFileForRead: return "FailedToOpenFileForRead"; case ErrorCode::FailedToOpenFileForWrite: return "FailedToOpenFileForWrite"; case ErrorCode::FailedToLaunchProcess: return "FailedToLaunchProcess"; case ErrorCode::Last: return "Last"; default: return "Last"; } } ErrorCode FromString(const std::string &errorCode) { if ("OK" == errorCode) { return ErrorCode::OK; } else if("OutOfSpace" == errorCode) { return ErrorCode::OutOfSpace; } else if("ConnectionFailure" == errorCode) { return ErrorCode::ConnectionFailure; } else if("InvalidJson" == errorCode) { return ErrorCode::InvalidJson; } else if("DatabaseFailure" == errorCode) { return ErrorCode::DatabaseFailure; } else if("HttpError" == errorCode) { return ErrorCode::HttpError; } else if("FileSystemError" == errorCode) { return ErrorCode::FileSystemError; } else if("FailedToEncrypt" == errorCode) { return ErrorCode::FailedToEncrypt; } else if("FailedToDecrypt" == errorCode) { return ErrorCode::FailedToDecrypt; } else if("EndOfFile" == errorCode) { return ErrorCode::EndOfFile; } else if("FailedToOpenFileForRead" == errorCode) { return ErrorCode::FailedToOpenFileForRead; } else if("FailedToOpenFileForWrite" == errorCode) { return ErrorCode::FailedToOpenFileForWrite; } else if("FailedToLaunchProcess" == errorCode) { return ErrorCode::FailedToLaunchProcess; } else if("Last" == errorCode) { return ErrorCode::Last; } return ErrorCode::Last; } }

Ponder などのリフレクションライブラリを使用できます。列挙型を登録し、APIを使用してそれらを前後に変換できます。

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"

それがそれを行う唯一の方法です（文字列の配列も機能します）。

問題は、Cプログラムがコンパイルされると、enumのバイナリ値がすべて使用され、名前がなくなることです。

列挙型を文字列に簡単に変換するために作成したCLIプログラムを次に示します。使いやすく、完了するには約5秒かかります（プログラムを含むディレクトリにcdしてから実行し、enumを含むファイルを渡す時間を含む）。

ここからダウンロード： http://www.mediafire.com/?nttignoozzz

ここでの議論のトピック： http：//cboard.cprogramming。 com / projects-job-recruitment / 127488-free-program-im-sharing-convertenumtostrings.html

<！> quot;-help <！> quot;でプログラムを実行します。引数を使用して説明を取得します。

少し前に、QComboBoxで列挙型を適切に表示し、列挙型と文字列表現を1つのステートメントとして定義するためのトリックを作成しました

#pragma once #include <boost/unordered_map.hpp> namespace enumeration { struct enumerator_base : boost::noncopyable { typedef boost::unordered_map<int, std::wstring> kv_storage_t; typedef kv_storage_t::value_type kv_type; kv_storage_t const & kv() const { return storage_; } LPCWSTR name(int i) const { kv_storage_t::const_iterator it = storage_.find(i); if(it != storage_.end()) return it->second.c_str(); return L"empty"; } protected: kv_storage_t storage_; }; template<class T> struct enumerator; template<class D> struct enum_singleton : enumerator_base { static enumerator_base const & instance() { static D inst; return inst; } }; } #define QENUM_ENTRY(K, V, N) K, N storage_.insert(std::make_pair((int)K, V)); #define QBEGIN_ENUM(NAME, C) \ enum NAME \ { \ C \ } \ }; \ } \ #define QEND_ENUM(NAME) \ }; \ namespace enumeration \ { \ template<> \ struct enumerator<NAME>\ : enum_singleton< enumerator<NAME> >\ { \ enumerator() \ { //usage /* QBEGIN_ENUM(test_t, QENUM_ENTRY(test_entry_1, L"number uno", QENUM_ENTRY(test_entry_2, L"number dos", QENUM_ENTRY(test_entry_3, L"number tres", QEND_ENUM(test_t))))) */

列挙型を文字列に変換できるenumeration::enum_singleton<your_enum>::instance()ができました。 kv_storage_tをboost::bimapに置き換えると、逆方向の変換も可能になります。 Qtオブジェクトはテンプレートにできなかったため、コンバーターの共通基本クラスが導入され、Qtオブジェクトに格納されました

以前の外観

バリアントとして、単純なlib <！> gt;を使用します。 http://codeproject.com/Articles/42035 / Enum-to-String-and-Vice-in-C

コード内

#include <EnumString.h> enum FORM { F_NONE = 0, F_BOX, F_CUBE, F_SPHERE, };

行を追加

Begin_Enum_String( FORM ) { Enum_String( F_NONE ); Enum_String( F_BOX ); Enum_String( F_CUBE ); Enum_String( F_SPHERE ); } End_Enum_String;

問題なく動作します。 enumの値が重複していない場合。

使用例

enum FORM f = ... const std::string& str = EnumString< FORM >::From( f );

およびその逆

assert( EnumString< FORM >::To( f, str ) );

<！> lt; <！> lt;を取得する試みです。および<！> gt; <！> gt;列挙型のストリーム演算子は、1行のマクロコマンドのみで自動的に...

定義：

#include <string> #include <iostream> #include <stdexcept> #include <algorithm> #include <iterator> #include <sstream> #include <vector> #define MAKE_STRING(str, ...) #str, MAKE_STRING1_(__VA_ARGS__) #define MAKE_STRING1_(str, ...) #str, MAKE_STRING2_(__VA_ARGS__) #define MAKE_STRING2_(str, ...) #str, MAKE_STRING3_(__VA_ARGS__) #define MAKE_STRING3_(str, ...) #str, MAKE_STRING4_(__VA_ARGS__) #define MAKE_STRING4_(str, ...) #str, MAKE_STRING5_(__VA_ARGS__) #define MAKE_STRING5_(str, ...) #str, MAKE_STRING6_(__VA_ARGS__) #define MAKE_STRING6_(str, ...) #str, MAKE_STRING7_(__VA_ARGS__) #define MAKE_STRING7_(str, ...) #str, MAKE_STRING8_(__VA_ARGS__) #define MAKE_STRING8_(str, ...) #str, MAKE_STRING9_(__VA_ARGS__) #define MAKE_STRING9_(str, ...) #str, MAKE_STRING10_(__VA_ARGS__) #define MAKE_STRING10_(str) #str #define MAKE_ENUM(name, ...) MAKE_ENUM_(, name, __VA_ARGS__) #define MAKE_CLASS_ENUM(name, ...) MAKE_ENUM_(friend, name, __VA_ARGS__) #define MAKE_ENUM_(attribute, name, ...) name { __VA_ARGS__ }; \ attribute std::istream& operator>>(std::istream& is, name& e) { \ const char* name##Str[] = { MAKE_STRING(__VA_ARGS__) }; \ std::string str; \ std::istream& r = is >> str; \ const size_t len = sizeof(name##Str)/sizeof(name##Str[0]); \ const std::vector<std::string> enumStr(name##Str, name##Str + len); \ const std::vector<std::string>::const_iterator it = std::find(enumStr.begin(), enumStr.end(), str); \ if (it != enumStr.end())\ e = name(it - enumStr.begin()); \ else \ throw std::runtime_error("Value \"" + str + "\" is not part of enum "#name); \ return r; \ }; \ attribute std::ostream& operator<<(std::ostream& os, const name& e) { \ const char* name##Str[] = { MAKE_STRING(__VA_ARGS__) }; \ return (os << name##Str[e]); \ }

使用法：

// Declare global enum enum MAKE_ENUM(Test3, Item13, Item23, Item33, Itdsdgem43); class Essai { public: // Declare enum inside class enum MAKE_CLASS_ENUM(Test, Item1, Item2, Item3, Itdsdgem4); }; int main() { std::cout << Essai::Item1 << std::endl; Essai::Test ddd = Essai::Item1; std::cout << ddd << std::endl; std::istringstream strm("Item2"); strm >> ddd; std::cout << (int) ddd << std::endl; std::cout << ddd << std::endl; }

このスキームの制限についてはわかりませんが...コメントは歓迎します！

#include <iostream> #include <map> #define IDMAP(x) (x,#x) std::map<int , std::string> enToStr; class mapEnumtoString { public: mapEnumtoString(){ } mapEnumtoString& operator()(int i,std::string str) { enToStr[i] = str; return *this; } public: std::string operator [] (int i) { return enToStr[i]; } }; mapEnumtoString k; mapEnumtoString& init() { return k; } int main() { init() IDMAP(1) IDMAP(2) IDMAP(3) IDMAP(4) IDMAP(5); std::cout<<enToStr[1]; std::cout<<enToStr[2]; std::cout<<enToStr[3]; std::cout<<enToStr[4]; std::cout<<enToStr[5]; }

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow