How do i ToString() an enum in c++? [duplicate]

Answer 1

You have to do it manually, i.e.

const char* ToString(Colours co) {
     switch(co) {
        case Red:
           return "Red";
        // ...
     }
}

A lookup table would also be possible. I've also seen people using custom scripts to generate such stuff on top of their source code.

Answer 2

I really like the macro approach of @Lol4t0.

I extended it to be able to convert an enum from a string too:

#include <iostream>
#include <string>
#include <vector>

// http://stackoverflow.com/questions/236129/how-to-split-a-string-in-c
std::vector<std::string> split(const std::string &text, char sep) {
    std::vector<std::string> tokens;
    int start = 0, end = 0;
    while ((end = text.find(sep, start)) != std::string::npos) {
        tokens.push_back(text.substr(start, end - start));
        start = end + 1;
    }
    tokens.push_back(text.substr(start));
    return tokens;
}

#define ENUM(name, ...)\
    enum name\
    {\
        __VA_ARGS__\
    };\
    static const int name##Size = (sizeof((int[]){__VA_ARGS__})/sizeof(int));\
    static const vector<string> name##ToStringMap = split(#__VA_ARGS__, ',');\
    const string name##ToString(const name value)\
    {\
        return name##ToStringMap.at(value);\
    };\
    map<string, name> name##ToFromStringMap(...)\
    {\
        map<string, name> m;\
        name args[name##Size] = { __VA_ARGS__ };\
        \
        int i;\
        for(i = 0; i < name##Size; ++i)\
        {\
            m[name##ToString(args[i])] = args[i];\
        }\
        return m;\
    };\
    static map<string, name> name##FromStringMap = name##ToFromStringMap(__VA_ARGS__);\
    const name name##FromString(const string value, const name defaultValue)\
    {\
        if(name##FromStringMap.count(value) == 0)\
        {\
            return defaultValue;\
        }\
        return name##FromStringMap[value];\
    };

Usage:

ENUM(MyEnum, Value1, Value2)

void main()
{
    string valueName = MyEnumToString(MyEnum::Value2);
    MyEnum value = MyEnumFromString(valueName, MyEnum::Value1);
}

I am not a C++ expert, so let me know what you think or how to do better.

Answer 3

That's inherently impossible.

A C++ enum is just a set of numbers with compile-time names.
At runtime, they are indistinguishable from ordinary numbers.

You need to write a switch statement that returns a string.

Answer 4

While this is commonly done through switches, I prefer arrays:

#include <iostream>

namespace foo {
  enum Colors { BLUE = 0, RED, GREEN, SIZE_OF_ENUM };
  static const char* ColorNames[] = { "blue", "red", "green" };

  // statically check that the size of ColorNames fits the number of Colors
  static_assert(sizeof(foo::ColorNames)/sizeof(char*) == foo::SIZE_OF_ENUM
    , "sizes dont match");
} // foo

int main()
{
  std::cout << foo::ColorNames[foo::BLUE] << std::endl;
  return 0;
}

The explicit array size has the benefit of generating a compile time error should the size of the enum change and you forget to add the appropriate string.

Alternatively, there is Boost.Enum in the Boost vault. The library hasn't been officially released but is quite stable and provides what you want. I wouldn't recommend it to a novice though.

Answer 5

enum Color
{
    Red =0,
    Green=1,
    Blue=2
};

std::string ColorMap[] = { "Red", "Green","Blue" };

Use ColorMap[c] to get the string representation:

std::string msg = "Invalid colour '" + ColorMap[c] + "' selected.";

---

However, if the values of enum are not continuous, then you can use std::map instead as:

enum Color
{
    Red   = 0x1,
    Green = 0x2,
    Blue  = 0x4, 
    Black = 0x8, 
};

//C++11 only, as it uses std::initializer_list
std::map<Color, std::string> ColorMap = {
    {Red, "Red"},
    {Green, "Green"},
    {Blue, "Blue"},
    {Black, "Black"}
};

//same as before!
std::string msg = "Invalid colour '" + ColorMap[c] + "' selected.";

Answer 6

As @FlopCoder said:

enum Colours
{
    Red =0,
    Green=1,
    Blue=2
};
char* ColourNames[] = { "Red", "Green", "Blue" };
int colour = Green;
printf( "Invalid colour '%s' selected.", ColourNames[ colour ] );

This of course will only work if your enum starts at 0 and is continuous.
@Nawaz's way is more C++ stylish though.