C ++ 11'de bir enum sınıfının değerini nasıl çıkarabilirim

enum classC ++ 11'de an'ın değerini nasıl çıkarabilirim ? C ++ 03'te şöyle:

#include <iostream>

using namespace std;

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

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

c ++ 0x'de bu kod derlenmez

#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'da derlendi

Kapsamlı bir numaralandırmanın aksine, kapsamlı bir numaralandırma örtük olarak tamsayı değerine dönüştürülemez. Buna gerek açıkça bir döküm kullanarak bir tam sayıya dönüştürmek:

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

Mantığı bir işlev şablonuna kapsüllemek isteyebilirsiniz:

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

olarak kullanılır:

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

İkinci örneğinizin (yani, kapsamlı bir enum kullanan) kapsamsız numaralandırmalarla aynı sözdizimini kullanarak çalışması mümkündür. Ayrıca, çözelti genel olduğunu ve (gösterildiği gibi, her kapsamına sahip enum için kod yazma karşı, her kapsamlı enums için çalışacaktır yanıt sağladığı @ForEveR ).

Çözüm, operator<<herhangi bir kapsamlı enum için çalışacak genel bir işlev yazmaktır . Çözüm, SFINAE aracılığıyla kullanır std::enable_ifve aşağıdaki gibidir.

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

(Henüz yorum yapmama izin verilmiyor.) James McNellis'in halihazırda harika olan cevabına aşağıdaki iyileştirmeleri öneririm:

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

ile

• constexpr: derleme zamanı dizi boyutu olarak bir enum üye değeri kullanmama izin veriyor
• static_assert+ is_enum: fonksiyonun derleme zamanını 'sağlamak' için. önerildiği gibi yalnızca numaralandırmalarla

Bu arada kendime soruyorum: enum classEnum üyelerime sayı değerleri atamak istediğimde neden kullanmalıyım ?! Dönüşüm çabasını göz önünde bulundurarak.

Belki daha sonra enumburada önerdiğim gibi sıradanlığa geri dönerim : Numaralandırmaları C ++ 'da bayrak olarak nasıl kullanabilirim?

Bir @TobySpeight önerisine dayanarak, static_assert içermeyen bir başka (daha iyi) çeşidi:

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

Daha basit yazmak için,

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

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

Aşağıdakiler benim için C ++ 11'de çalıştı:

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

Bunun gibi bir şey yapabilirsiniz:

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