ฉันจะส่งออกค่าของคลาส enum ใน C ++ 11 ได้อย่างไร

ฉันจะส่งออกค่าของenum classใน C ++ 11 ได้อย่างไร ใน C ++ 03 จะเป็นเช่นนี้:

#include <iostream>

using namespace std;

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

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

ใน c ++ 0x รหัสนี้ไม่ได้รวบรวม

#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]'

รวบรวมที่Ideone.com

ไม่เหมือนกับการแจงนับที่ไม่ได้กำหนดขอบเขตการแจงนับตามขอบเขตจะไม่สามารถแปลงเป็นค่าจำนวนเต็มได้โดยปริยาย คุณจำเป็นต้องชัดเจนแปลงเป็นจำนวนเต็มโดยใช้หล่อ:

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

คุณอาจต้องการห่อหุ้มลอจิกลงในเทมเพลตฟังก์ชัน:

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);
}

ใช้เป็น:

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;
}

เป็นไปได้ที่จะรับตัวอย่างที่สองของคุณ (เช่นตัวอย่างที่ใช้ขอบเขตขอบเขต) เพื่อทำงานโดยใช้ไวยากรณ์เดียวกันกับ enums ที่ไม่ได้กำหนดขอบเขต นอกจากนี้โซลูชันยังเป็นแบบทั่วไปและจะใช้ได้กับ enums ที่กำหนดขอบเขตทั้งหมดเทียบกับการเขียนโค้ดสำหรับแต่ละขอบเขตที่กำหนด (ดังแสดงในคำตอบที่ให้ไว้โดย@ForEveR )

วิธีแก้ปัญหาคือการเขียนoperator<<ฟังก์ชันทั่วไปซึ่งจะใช้ได้กับ enum ที่กำหนดขอบเขตใด ๆ โซลูชันนี้ใช้SFINAEผ่านstd::enable_ifและมีดังต่อไปนี้

#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;
}

(ฉันยังไม่ได้รับอนุญาตให้แสดงความคิดเห็น) ฉันขอแนะนำการปรับปรุงต่อไปนี้สำหรับคำตอบที่ยอดเยี่ยมของ 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);
}

ด้วย

• constexpr: อนุญาตให้ฉันใช้ค่าสมาชิก enum เป็นขนาดอาร์เรย์คอมไพล์ไทม์
• static_assert+ is_enum: เพื่อ 'ให้แน่ใจ' เวลาคอมไพล์ว่าฟังก์ชันทำ sth ด้วยการแจงนับเท่านั้นตามที่แนะนำ

ฉันถามตัวเองว่า: ทำไมฉันถึงต้องใช้enum classเมื่อฉันต้องการกำหนดค่าตัวเลขให้กับสมาชิก enum ของฉัน! พิจารณาความพยายามในการแปลง

บางทีฉันอาจจะกลับไปenumเป็นธรรมดาตามที่แนะนำไว้ที่นี่: จะใช้ enums เป็นแฟล็กใน C ++ ได้อย่างไร?

อีกหนึ่งรสชาติ (ดีกว่า) ของมันโดยไม่มี static_assert ตามคำแนะนำของ @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);
}

หากต้องการเขียนให้ง่ายขึ้น

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

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

การติดตามทำงานให้ฉันใน 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);
}

คุณสามารถทำสิ่งนี้:

//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;