Вывод перечисления в виде текста

///----------------------------------------------------------------------------|
/// ...
///----------------------------------------------------------------------------:
#include <iostream>
#include <string>
#include <map>
 
enum Enum
{
    Nine = 9,
    One  = 1,
    Two     ,
    None = 0
};
 
struct  What
{       What()
        {
            m[Nine] = "Nine";
            m[One ] = "One" ;
            m[Two ] = "Two" ;
 
            /// про None забыли.
        };
 
        std::string operator()(Enum e) const
        {   auto a = m.find(e);
            return std::to_string(e) + ": " + (a == m.end() ? "??" : a->second);
        }
 
private:
    std::map<Enum, std::string> m;
};
const What WHAT;
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{
    Enum                    my = Two;
    std::cout <<       WHAT(my) << '\n';
 
                            my = Nine;
    std::cout <<       WHAT(my) << '\n';
 
                            my = None;
    std::cout <<       WHAT(my) << '\n';
 
                            my = One;
    std::string  str = WHAT(my);
    std::cout << str  << '\n';
}

#include <string>
#include <iostream>
 
class some_class
{
public:
    enum class e_myenum
    {
        one,
        two,
    };
    friend std::string toString(const e_myenum& val)
    {
        std::string str;
        switch(val)
        {
            default:break;
            case e_myenum::one: str="one";break;
            case e_myenum::two: str="two";break;
        }
        return str;
    }
    friend void fromString(e_myenum& val,const std::string_view str)
    {
        val={};
        if(str.empty())return;
        if(str=="one"){val=e_myenum::one; return;}
        if(str=="two"){val=e_myenum::two; return;}
    }
};
 
 
int main()
{
    some_class::e_myenum value{};
    auto str=toString(value);
    
    some_class::e_myenum new_value{};
    fromString(new_value,str);
    
    std::cout<<str<<", comparing=="<<(value==new_value);
    
    return 0;
}

struct  What
{
    inline static std::unordered_map<Enum, std::string> to
    {
        {Nine,"Nine"},
        {One ,"One"},
        {Two ,"Two"},
    };
    
    std::string operator()(const Enum e) const
    {
        if(auto a = to.find(e); a!=to.end()){return a->second;}
        return "??";
    }
};

#include "myenum.h"
 
/// какой угодно енам:
enum Enum
{
    Nine = 9,
    One  = 1,
    Two     ,
    None = 0
};
 
const mylib::WHAT WHAT(
R"(
    Nine = 9,
    One  = 1,
    Two     ,
    None = 0
)"
);
 
/// если есть ещё енамы  то тут всё также аналогично тому, что выше
...
 
/// тут всё тоже самое, как выше.

enum EMvPolarity
{
   keMvPolarityInvalid,                   // Invalid value.
   keMvPolarityFirstField,                // Indicates that the surface is a first field.
   keMvPolaritySecondField,               // Indicates that the surface is a second field.
   keMvPolarityInterlacedFieldsInAFrame,  // Indicates that the surface is a frame containing two interlaced fields.
   keMvPolarityProgressiveFrame,          // Indicates that the surface is a progressive frame.
   keMvPolarityBackToBackFieldsInAFrame,  // Indicates that the surface is a frame containing two back-to-back fields.
   keMvPolarityLast                       // End of list indicator.
};
// This macro is used to get the string of the enum value EMvPolarity.
#define MV_POLARITY_ENUM_TO_STRING(ePolarity) \
   ((ePolarity == keMvPolarityInvalid)                 ? ("Invalid") : \
   (ePolarity == keMvPolarityFirstField)               ? ("FirstField") : \
   (ePolarity == keMvPolaritySecondField)              ? ("SecondField") : \
   (ePolarity == keMvPolarityInterlacedFieldsInAFrame) ? ("InterlacedFieldsInAFrame") : \
   (ePolarity == keMvPolarityProgressiveFrame)         ? ("ProgressiveFrame") : \
   (ePolarity == keMvPolarityBackToBackFieldsInAFrame) ? ("BackToBackFieldsInAFrame") : \
   (ePolarity == keMvPolarityLast)                     ? ("Last") : \
   ("???"))

#include <string>
#include <iostream>
 
enum class e_myenum
{
    one,
    two,
};
/*inline - если это расположено в *.h */ std::string toString(const e_myenum& val)
{
    std::string str;
    switch(val)
    {
        default:break;
        case e_myenum::one: str="one";break;
        case e_myenum::two: str="two";break;
    }
    return str;
}
/*inline - если это расположено в *.h */ void fromString(e_myenum& val,const std::string_view str)
{
    val={};
    if(str.empty())return;
    if(str=="one"){val=e_myenum::one; return;}
    if(str=="two"){val=e_myenum::two; return;}
}
 
int main()
{
    e_myenum value{};
    auto str=toString(value);
    
    e_myenum new_value{};
    fromString(new_value,str);
    
    std::cout<<str<<", comparing=="<<(value==new_value);
    
    return 0;
}

/// C++17
///----------------------------------------------------------------------------|
/// ...
///----------------------------------------------------------------------------:
#include <iostream>
#include <string>
#include <map>
 
template<typename T>
using ce_t = const std::initializer_list<std::pair<T, std::string>>;
 
#define LOAD(v) {v, #v}
 
template<typename T>
struct  What
{       What(ce_t<T> a) : m(a.begin(), a.end()){}
 
        std::string operator()(T e) const
        {   auto a = m.find(e);
            return std::to_string(e) + ": " + (a == m.end() ? "??" : a->second);
        }
 
private:
    const std::map<T, std::string> m;
};
 
///--------|
/// Enum1  |
///--------:
enum Enum1
{   Nine = 9,
    One  = 1
};
 
const What<Enum1> WHAT1(
{   LOAD(Nine),
    LOAD(One )
});
 
///--------|
/// Enum2  |
///--------:
enum Enum2
{   Two  = 2,
    None = 0
};
 
const What<Enum2> WHAT2(
{   LOAD(Two )
    /// про None забыли.
});
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{
    Enum1              my1 = One;
    std::cout << WHAT1(my1) << '\n';
 
    Enum2              my2 = Two;
    std::cout << WHAT2(my2) << '\n';
 
                       my2 = None;
    std::cout << WHAT2(my2) << '\n';
}