如何将枚举类写入文件并在C ++中访问它？

Question

I am trying to write the contents of a class object into a file. The object has an enum class member and I am unable to write it into a file using ofstream.

I get the following error.

error: no match for ‘operator<<’ (operand types are ‘std::basic_ostream<char>’ and ‘EnumClass_scope::EnumCass_name’)

Any leads would be helpful.

Answer 1

One way is to cast the enum type to the underlaying type. This can be done with already defined std::underlying_type_t to get the internal representation of the enum.

    template < typename T>
auto toUnderlayingType( T t )
{
    return static_cast<std::underlying_type_t< T >>( t );
}

    template < typename T, typename U = std::underlying_type_t< T > >
void readToEnum( U u , T& t )
{
    t = static_cast< T >( u );
}

class Y
{
    public:

        enum class X
        {
            ONE,
            TWO
        } x;

        Y(): x{X::ONE} { }

        void Print()
        {
            std::cout << toUnderlayingType(x) << std::endl;
        }

        void Read()
        {
            std::underlying_type_t< X > tmp;
            std::cin >> tmp;
            readToEnum( x, tmp );
        }
};



int main()
{
    Y y;
    y.Print();
}

But in the case of serialization it is even better to use a better representation of content and data. As reflection is still not part of c++ you have to convert the enum value to any useful output and back. Maybe you will write text like "ONE" instead of 0 to the file. But all this is to broad for this answer. There are a long list of serializer libraries like boost and cerial

And you have to check if the incoming value is a valid one. Having the example above and assign a numerical 3 to it, the enum value is invalid. That topic is already discussed here: What happens if you static_cast invalid value to enum class?

Answer 2

Another option would be to manually overload the << operator for your enum:

#include <iostream>

enum class ESomething
{
    Nothing,
    Something,
    Everything,
};

std::ostream& operator<<(std::ostream& os, const ESomething& other)
{
    switch (other)
    {
    case ESomething::Nothing:
        os << "Nothing";
        break;
    case ESomething::Something:
        os << "Something";
        break;
    case ESomething::Everything:
        os << "Everything";
        break;
    default:
        break;        
    }
    return os;
    // Alternatively: std::cout << std::underlying_type(other); return os;
}

int main()
{
    ESomething hello = ESomething::Something;
    std::cout << hello << '\n';

    return 0;
}

Where you could decide exactly what to output on each separate case, or simply cast it to the underlying type as other answers have mentioned and output that. The choice is yours.

Answer 3

Convert variable to integer before writing. Use integer temporary variable when reading.

std::fstream stream;
enum class Enum { ... };

Enum variable;
stream << static_cast<int>(variable);

int temporary;
stream >> temporary;
variable = static_cast<Enum>(temporary);

If you defined enum with other type than int , use that type. For example, with enum class Enum : unsigned long long , use static_cast<unsigned long long> .