Question

If I have an enum like this:

enum Errors {
    ErrorA = 0,
    ErrorB,
    ErrorC,
};

Then I want to print it out to console:

Errors anError = ErrorA;
std::cout << anError; // 0 will be printed

But what I want is the text "ErrorA". Can I do it without using if/switch? And what is your solution for this?

Answer 1

Using map:

#include <map>
#include <string_view>

enum Errors {ErrorA=0, ErrorB, ErrorC};

std::ostream& operator<<(std::ostream& out, const Errors value){
    // prior to C++11, create a function outside instead of using a lambda
    static const auto strings = []{
        // prior to C++17, replace std::string_view with
        // std::string or const char*
        std::map<Errors, std::string_view> result;
    #define INSERT_ELEMENT(p) result.emplace(p, #p);
        INSERT_ELEMENT(ErrorA);     
        INSERT_ELEMENT(ErrorB);     
        INSERT_ELEMENT(ErrorC);             
    #undef INSERT_ELEMENT
        return result;
    };
    
    return out << strings[value];
}

Using array of structures with linear search:

#include <string_view>

enum Errors {ErrorA=0, ErrorB, ErrorC};

std::ostream& operator<<(std::ostream& out, const Errors value){
#define MAPENTRY(p) {p, #p}
    const struct MapEntry{
        Errors value;
        std::string_view str;
    } entries[] = {
        MAPENTRY(ErrorA),
        MAPENTRY(ErrorB),
        MAPENTRY(ErrorC),
        {ErrorA, 0}//doesn't matter what is used instead of ErrorA here...
    };
#undef MAPENTRY
    const char* s = 0;
    for (const MapEntry* i = entries; i->str; i++){
        if (i->value == value){
            s = i->str;
            break;
        }
    }

    return out << s;
}

Using switch/case:

#include <string>

enum Errors {ErrorA=0, ErrorB, ErrorC};

std::ostream& operator<<(std::ostream& out, const Errors value){
    return out << [value]{
    #define PROCESS_VAL(p) case(p): return #p;
        switch(value){
            PROCESS_VAL(ErrorA);     
            PROCESS_VAL(ErrorB);     
            PROCESS_VAL(ErrorC);
        }
    #undef PROCESS_VAL
    };
}

Test the solutions:

#include <iostream>

int main(int argc, char** argv){
    std::cout << ErrorA << std::endl << ErrorB << std::endl << ErrorC << std::endl;
    return 0;   
}