Làm cách nào để xuất giá trị của một lớp enum trong C ++ 11

Làm cách nào để xuất giá trị của an enum classtrong C ++ 11? Trong C ++ 03 nó như thế này:

#include <iostream>

using namespace std;

enum A {
  a = 1,
  b = 69,
  c= 666
};

int main () {
  A a = A::c;
  cout << a << endl;
}

trong c ++ 0x mã này không biên dịch

#include <iostream>

using namespace std;

enum class A {
  a = 1,
  b = 69,
  c= 666
};

int main () {
  A a = A::c;
  cout << a << endl;
}


prog.cpp:13:11: error: cannot bind 'std::ostream' lvalue to 'std::basic_ostream<char>&&'
/usr/lib/gcc/i686-pc-linux-gnu/4.5.1/../../../../include/c++/4.5.1/ostream:579:5: error:   initializing argument 1 of 'std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char, _Traits = std::char_traits<char>, _Tp = A]'

tổng hợp tại Ideone.com

Không giống như kiểu liệt kê không theo dõi, kiểu liệt kê có phạm vi không hoàn toàn có thể chuyển đổi thành giá trị nguyên của nó. Bạn cần chuyển đổi nó thành một số nguyên một cách rõ ràng bằng cách sử dụng một kiểu:

std::cout << static_cast<std::underlying_type<A>::type>(a) << std::endl;

Bạn có thể muốn đóng gói logic vào một mẫu hàm:

template <typename Enumeration>
auto as_integer(Enumeration const value)
    -> typename std::underlying_type<Enumeration>::type
{
    return static_cast<typename std::underlying_type<Enumeration>::type>(value);
}

được dùng như:

std::cout << as_integer(a) << std::endl;

#include <iostream>
#include <type_traits>

using namespace std;

enum class A {
  a = 1,
  b = 69,
  c= 666
};

std::ostream& operator << (std::ostream& os, const A& obj)
{
   os << static_cast<std::underlying_type<A>::type>(obj);
   return os;
}

int main () {
  A a = A::c;
  cout << a << endl;
}

Có thể lấy ví dụ thứ hai của bạn (ví dụ: ví dụ sử dụng một enum có phạm vi) hoạt động bằng cách sử dụng cùng một cú pháp với enum chưa được mở. Hơn nữa, giải pháp là chung và sẽ hoạt động cho tất cả các enum có phạm vi, so với việc viết mã cho mỗi enum trong phạm vi (như được hiển thị trong câu trả lời được cung cấp bởi @ForEveR ).

Giải pháp là viết một operator<<hàm chung sẽ hoạt động cho bất kỳ enum có phạm vi nào. Giải pháp sử dụng SFINAE thông quastd::enable_if và như sau.

#include <iostream>
#include <type_traits>

// Scoped enum
enum class Color
{
    Red,
    Green,
    Blue
};

// Unscoped enum
enum Orientation
{
    Horizontal,
    Vertical
};

// Another scoped enum
enum class ExecStatus
{
    Idle,
    Started,
    Running
};

template<typename T>
std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e)
{
    return stream << static_cast<typename std::underlying_type<T>::type>(e);
}

int main()
{
    std::cout << Color::Blue << "\n";
    std::cout << Vertical << "\n";
    std::cout << ExecStatus::Running << "\n";
    return 0;
}

(Tôi chưa được phép bình luận.) Tôi sẽ đề xuất những cải tiến sau cho câu trả lời vốn đã tuyệt vời của James McNellis:

template <typename Enumeration>
constexpr auto as_integer(Enumeration const value)
    -> typename std::underlying_type<Enumeration>::type
{
    static_assert(std::is_enum<Enumeration>::value, "parameter is not of type enum or enum class");
    return static_cast<typename std::underlying_type<Enumeration>::type>(value);
}

với

• constexpr: cho phép tôi sử dụng giá trị thành viên enum làm kích thước mảng thời gian biên dịch
• static_assert+ is_enum: để 'đảm bảo' thời gian biên dịch mà hàm thực hiện thứ. chỉ với liệt kê, như được đề xuất

Nhân tiện, tôi tự hỏi mình: Tại sao tôi nên sử dụng enum class khi tôi muốn gán giá trị số cho các thành viên enum của mình ?! Xem xét nỗ lực chuyển đổi.

Có lẽ sau đó tôi sẽ trở lại bình thường enumnhư tôi đã đề xuất ở đây: Làm thế nào để sử dụng enum làm cờ trong C ++?

Tuy nhiên, một hương vị khác (tốt hơn) của nó mà không có static_assert, dựa trên đề xuất của @TobySpeight:

template <typename Enumeration>
constexpr std::enable_if_t<std::is_enum<Enumeration>::value,
std::underlying_type_t<Enumeration>> as_number(const Enumeration value)
{
    return static_cast<std::underlying_type_t<Enumeration>>(value);
}

Để viết đơn giản hơn,

enum class Color
{
    Red = 1,
    Green = 11,
    Blue = 111
};

int value = static_cast<int>(Color::Blue); // 111

Sau đây đã làm việc cho tôi trong C ++ 11:

template <typename Enum>
constexpr typename std::enable_if<std::is_enum<Enum>::value,
                                  typename std::underlying_type<Enum>::type>::type
to_integral(Enum const& value) {
    return static_cast<typename std::underlying_type<Enum>::type>(value);
}

Bạn có thể làm điều gì đó như sau:

//outside of main
namespace A
{
    enum A
    {
        a = 0,
        b = 69,
        c = 666
    };
};

//in main:

A::A a = A::c;
std::cout << a << std::endl;