編譯時檢查字符串枚舉映射是否完成

Question

這個問題很可能是"How to map strings to enums"的第n次迭代。

我的要求更進一步，我想throw某個異常，如果在有效輸入範圍內找不到鍵。所以我有這個執行本EnumMap（需求拉動const std::map定義）：

#include <map> 
#include <string> 
#include <sstream> 
#include <stdexcept> 
#include <boost/assign.hpp> 

typedef enum colors { 
    RED, 
    GREEN, 
} colors; 
// boost::assign::map_list_of 
const std::map<std::string,int> colorsMap = boost::assign::map_list_of 
              ("red", RED) 
              ("green", GREEN); 
//----------------------------------------------------------------------------- 
// wrapper for a map std::string --> enum 
class EnumMap { 
private: 
    std::map<std::string,int> m_map; 
    // print the map to a string 
    std::string toString() const { 
    std::string ostr; 
    for(auto x : m_map) { 
     ostr += x.first + ", "; 
    } 
    return ostr; 
    } 
public: 
    // constructor 
    EnumMap(const std::map<std::string,int> &m) : m_map(m) { } 
    // access 
    int at(const std::string &str_type) { 
    try{ 
     return m_map.at(str_type); 
    } 
    catch(std::out_of_range) { 
     throw(str_type + " is not a valid input, try : " + toString()); 
    } 
    catch(...) { 
     throw("Unknown exception"); 
    } 
    } 
}; 
//----------------------------------------------------------------------------- 
int main() 
{ 
    EnumMap aColorMap(colorsMap); 
    try { 
    aColorMap.at("red"); // ok 
    aColorMap.at("yellow"); // exception : "yellow is not a valid input ..." 
    } 
    catch(std::string &ex) { 
    std::cout << ex << std::endl; 
    } 
    return 0; 
} 

這工作得很好，做什麼，我需要的。現在，我希望能夠在編譯時知道某個enum中的所有元素都傳遞給EnumMap構造函數，並且enum中的所有元素都與相應的字符串匹配。

我試着用std::initializer_list和static_assert，但似乎VC2010不支持std::initializer_list（見here）。

有沒有人有如何實現這個想法？也許有模板，或者實現我自己的Enum類？

Answer 1

有沒有人有關於如何實現它的想法？也許有模板，或者實現我自己的Enum類？

這是不可能的。不適用於std :: map，不適用於模板元編程。

Answer 2

typedef enum colors { 
    MIN_COLOR, 
    RED = MIN_COLOR, 
    GREEN, 
    MAX_COLOR 
} colors; 

template< colors C > 
struct MapEntry { 
    std::string s; 
    MapEntry(std::string s_):s(s_) {} 
}; 
void do_in_order() {} 
template<typename F0, typename... Fs> 
void do_in_order(F0&& f0, Fs&&... fs) { 
    std::forward<F0>(f0)(); 
    do_in_order(std::forward<Fs>(fs)...); 
} 
struct MapInit { 
    std::map< std::string, color > retval; 
    operator std::map< std::string, color >() { 
    return std::move(retval); 
    } 
    template<colors C> 
    void AddToMap(MapEntry<C>&& ent) { 
    retval.insert(std::make_pair(std::move(end.s), C)); 
    } 
    template< typename... Entries > 
    MapInit(Entries&& entries) { 
    do_in_order([&](){ AddToMap(entries); }...); 
    } 
}; 
template<typename... Entries> 
MapInit mapInit(Entries&&... entries) { 
    return MapInit(std::forward<Entries>(entries)...); 
} 
const std::map<std::string, colors> = mapInit(MapEntry<RED>("red"), MapEntry<GREEN>("green")); 

，讓你從編譯時color構建std::map和運行時string數據的C++ 11的方式。

接下來在「列表MapEntry<colors>列表colors」元功能下。

template<colors... Cs> 
struct color_list {}; 
template<typename... Ts> 
struct type_list {}; 
template<typename MapEnt> 
struct extract_color; 
template<colors C> 
struct extract_color<MapEntry<C>> { 
    enum {value=C}; 
}; 
template<typename Entries> 
struct extract_colors; 
template<typename... MapEntries> 
struct extract_colors<type_list<MapEntries...>> { 
    typedef color_list< ((colors)extract_colors<MapEntries>::value)... > type; 
}; 

對該列表進行排序。檢測重複 - 如果有的話，你搞砸了。

編譯時排序比其餘部分和100多行代碼更難。如果你不介意太多，我會放棄它！ Here is a compile time merge sort I wrote in the past to answer a stack overflow question，它可以使用相對簡單的適應性（它使用值對類型進行排序，在這種情況下我們直接對編譯時間值列表進行排序）。

// takes a sorted list of type L<T...>, returns true if there are adjacent equal 
// elements: 
template<typename clist, typename=void> 
struct any_duplicates:std::false_type {}; 
template<typename T, template<T...>class L, T t0, T t1, T... ts> 
struct any_duplicates< L<t0, t1, ts...>, typename std::enable_if<t0==t1>::type>: 
    std::true_type {}; 
template<typename T, template<T...>class L, T t0, T t1, T... ts> 
struct any_duplicates< L<t0, t1, ts...>, typename std::enable_if<t0!=t1>::type>: 
    any_duplicates< L<t1, ts...> > {}; 

檢測的colors（即，<MIN_COLOR或>=MAX_COLOR）在有效範圍之外的元素。如果是這樣，你搞砸了。

template<typename List> 
struct min_max; 
template<typename T, template<T...>class L, T t0> 
struct min_max { 
    enum { 
    min = t0, 
    max = t1, 
    }; 
}; 
template<typename T, template<T...>class L, T t0, T t1, T... ts> 
struct min_max { 
    typedef min_max<L<t1, ts...>> rest_of_list; 
    enum { 
    rest_min = rest_of_list::min, 
    rest_max = rest_of_list::max, 
    min = (rest_min < t0):rest_min:t0, 
    max = (rest_max > t0):rest_max:t0, 
    }; 
}; 
template< typename T, T min, T max, typename List > 
struct bounded: std::integral_constant< bool, 
    (min_max<List>::min >= min) && (min_max<List>::max < max) 
> {}; 

算多少元素還有 - 應該有MAX_COLOR元素。如果沒有，你搞砸了。

template<typename List> 
struct element_count; 
template<typename T, template<T...>L, T... ts> 
struct element_count<L<ts...>>:std::integral_constant< std::size_t, sizeof...(ts) > {}; 

如果這些都沒有發生，那麼您必須初始化它們中的每一個。

唯一缺失的是你可能已經關閉了，並且對於兩個值使用相同的string。由於編譯時間string是一個痛苦，只需在運行時檢查它（在初始化之後，map中的條目數等於colors的數目）。

在C++ 03中這樣做會更困難。你缺乏variardic模板，所以你最終不得不僞造它們。這是一個痛苦。 mpl可能可以幫助您。

2012年11月MSVC CTP編譯器更新中提供了Variardic模板。

這是一個沒有重複檢查和沒有邊界檢查的玩具示例（它只是檢查地圖項的數量是否匹配）;

#include <cstddef> 
#include <utility> 
#include <string> 
#include <map> 

enum TestEnum { 
    BeginVal = 0, 
    One = BeginVal, 
    Two, 
    Three, 
    EndVal 
}; 

template<TestEnum e> 
struct MapEntry { 
    enum { val = e }; 
    std::string s; 
    MapEntry(std::string s_):s(s_) {} 
}; 

void do_in_order() {} 
template<typename F0, typename... Fs> 
void do_in_order(F0&& f0, Fs&&... fs) { 
    std::forward<F0>(f0)(); 
    do_in_order(std::forward<Fs>(fs)...); 
} 

template<typename... MapEntries> 
struct count_entries:std::integral_constant< std::size_t, sizeof...(MapEntries) > {}; 

// should also detect duplicates and check the range of the values: 
template<typename... MapEntries> 
struct caught_them_all: 
    std::integral_constant< 
    bool, 
    count_entries<MapEntries...>::value == (TestEnum::EndVal-TestEnum::BeginVal) 
    > 
{}; 

struct BuildMap { 
    typedef std::map<std::string, TestEnum> result_map; 
    mutable result_map val; 
    operator result_map() const { 
    return std::move(val); 
    } 
    template<typename... MapEntries> 
    BuildMap(MapEntries&&... entries) { 
    static_assert(caught_them_all<MapEntries...>::value, "Missing enum value"); 
    bool _[] = { ((val[ entries.s ] = TestEnum(MapEntries::val)), false)... }; 
    } 
}; 

std::map< std::string, TestEnum > bob = BuildMap(
    MapEntry<One>("One") 
    ,MapEntry<Two>("Two") 
#if 0 
    ,MapEntry<Three>("Three") 
#endif 
); 

int main() {} 

更換#if 0與#if 1看它編譯。 Live link如果你想玩。

Answer 3

我想發佈我最終到來的解決方案。我不想將它標記爲明確的答案，因爲我想弄清楚我們是否可以在編譯時定義字符串向量。

// 
// Cumstom Enum Header File 
// 

#include <vector> 
#include <string> 

#include <boost/algorithm/string/classification.hpp> 
#include <boost/algorithm/string/split.hpp> 
#include <boost/range/algorithm/find.hpp> 

std::vector<std::string> split_to_vector(std::string s) 
{ 
    // splits a comma separated string to a vector of strings 
    std::vector<std::string> v; 
    boost::split(v, s, boost::is_any_of(", "), boost::token_compress_on); 
    return v; 
} 

#define ENUM_TO_STRING(X,...) \ 
    struct X { \ 
     enum Enum {__VA_ARGS__}; \ 
     static \ 
     std::string to_string(X::Enum k) { \ 
      std::vector<std::string> keys = split_to_vector(#__VA_ARGS__); \ 
      return keys[static_cast<int>(k)]; \ 
     } \ 
     static \ 
     X::Enum which_one(const std::string s) { \ 
      std::vector<std::string> keys = split_to_vector(#__VA_ARGS__); \ 
      auto it = boost::find(keys, s); \ 
      if(it == keys.end()) { \ 
       throw("not a valid key"); \ 
      } \ 
      return static_cast<X::Enum>(it - keys.begin()); \ 
     } \ 
    } 


// 
// Usage 
// 

#include <iostream> 

ENUM_TO_STRING(Color, Red, Green, Blue); 

int main() 
{ 
    std::string red_s = Color::to_string(Color::Red); 
    std::cout << red_s << std::endl; 

    Color::Enum red_e = Color::which_one("Red"); 
    std::cout << red_e << std::endl; 

    // won't compile 
    // std::string yellow_s = Colors::to_string(Colors::Yellow); 

    // run-time error 
    // Color::Enum yellow_e = Colors::which_one("Yellow"); 
} 

上Coliru運行： http://coliru.stacked-crooked.com/a/e81e1af0145df99a