C++のような属性を持つC++のenums

Question

私はC++コードに変換する必要がある次のC＃コードを持っています。私は属性を持つC++ Enumsのやり方を少し調べたが、それを理解することはできない。

基本的に、属性を持つenumを行うC++の次の単純化されたC＃コードを表現する方法が必要です。

C＃コード：

enum Category{ 
    unknown = -1, meat, poultry, seafood, dairy, vegetable,fruit, grain, sweet 
}; 

typedef struct { 
    float calories; // calories 
    float carbonhydrates; // grams 
    float fat; // grams 
    float cholesterol; // grams 
    float sodium; // grams 
    float protein; // grams 
    Category category ; 
}Food; 

とどのように私は列挙型を使用して、構造体の値を呼び出しますので、もし：

public class PSMNameAttribute : Attribute 
     { 
      public string PSMName; 
      public PSMNameAttribute(string _PSMName) { PSMName = _PSMName; } 
     } 

public class PSMNumberAttribute : Attribute 
     { 
      public string PSMNumber; 
      public PSMNumberAttribute(string _PSMNumber) { PSMNumber = _PSMNumber; } 
     } 

public class PSMNumberNameAttribute : Attribute 
     { 
      public string PSMNumberName; 
      public PSMNumberNameAttribute(string _PSMNumberName) { PSMNumberName = _PSMNumberName; } 
     } 


public enum ShippingMethodsTypes 
     { 
      [PSMName("ErrorScriptMed")] 
      [PSMNumber("-5")] 
      [PSMNumberName("-5 ErrorScriptMed")] 
      ErrorScriptMed = -5     
      , 
      [PSMName("SpecialHandling")] 
      [PSMNumber("-1")] 
      [PSMNumberName("-1 SpecialHandling")] 
      SpecialHandling = -1     
      , 
      [PSMName("Error")] 
      [PSMNumber("0")] 
      [PSMNumberName("0 Error")] 
      Error = 0       
     } 

これは、次のように行われていませんか？

Answer 1

boost::variantと少数の訪問者は、うまくそれを解決する必要があります

#include <boost/variant.hpp> 
#include <iostream> 

struct get_number : boost::static_visitor<int> { 
    template<class Method> int operator()(const Method& m) const { return number(m); } 
}; 

struct get_name : boost::static_visitor<std::string> { 
    template<class Method> const std::string operator()(const Method& m) const { return name(m); } 
}; 

struct ShippingMethodMed {}; 
static constexpr int number(ShippingMethodMed) { return -5; } 
static std::string name(ShippingMethodMed) { return "ErrorScriptMedMed"; } 

struct ShippingMethodSpecialHandling { }; 
static constexpr int number(ShippingMethodSpecialHandling) { return -10; } 
static std::string name(ShippingMethodSpecialHandling) { return "SpecialHandling"; } 

struct ShippingMethodError {}; 
static constexpr int number(ShippingMethodError) { return 0; } 
static std::string name(ShippingMethodError) { return "Error"; } 

using ShippingMethod = boost::variant<ShippingMethodMed, ShippingMethodSpecialHandling, ShippingMethodError>; 

int number(ShippingMethod const& sm) { 
    return boost::apply_visitor(get_number(), sm); 
} 

std::string name(ShippingMethod const& sm) { 
    return boost::apply_visitor(get_name(), sm); 
} 

std::string number_name(ShippingMethod const& sm) { 
    return std::to_string(number(sm)) + " " + name(sm); 
} 


int main() 
{ 
    ShippingMethod m = ShippingMethodError(); 

    std::cout << number(m) << std::endl; 
    std::cout << name(m) << std::endl; 
    std::cout << number_name(m) << std::endl; 

    m = ShippingMethodSpecialHandling(); 

    std::cout << number(m) << std::endl; 
    std::cout << name(m) << std::endl; 
    std::cout << number_name(m) << std::endl; 
} 

Answer 2

これだけでは列挙型を持つことはできません。 私はあなたのようなあなたの列挙に文字列配列/ベクトル/マップまたはそれらの組み合わせを維持することによってこの問題を解決できると思いただし：

enum test 
{ 
    first = 0, 
    second, // = 1 
    // etc... 
}; 

const char* attributes[] = 
{ 
    "first attribute", 
    "second attribute", 
}; 

その後、あなたは「

const char* firstattribute = attributes[test::first];