मैं सी ++ 11

Question

में एनम क्लास के मान को कैसे आउटपुट कर सकता हूं I C++ 11 में enum class के मान को कैसे आउटपुट कर सकता हूं? सी ++ 03 में यह इस तरह है:

#include <iostream> 

using namespace std; 

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

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

ग में ++ 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]' 

एक unscoped गणन के विपरीत Ideone.com

Answer 1

पर संकलित, एक दायरे वाले गणन है निहित इसके पूर्णांक मान के लिए परिवर्तनीय नहीं है। आप की जरूरत स्पष्ट रूप से एक डाली का उपयोग कर एक पूर्णांक के लिए परिवर्तित:

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; 

Answer 2

std::cout << static_cast<std::underlying_type<A>::type>(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; 
} 

Answer 3

(मुझे अभी तक टिप्पणी करने की अनुमति नहीं है।) मैं निम्नलिखित सुधारों का सुझाव दूंगा जेम्स 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 करता है। enumerations के साथ ही, के रूप में सुझाव दिया

तरह से मैं अपने आप को पूछ रहा हूँ द्वारा: क्यों मैं कभी enum class का उपयोग करना चाहिए जब मैं अपने enum सदस्यों को नंबर प्रदान करना चाहते हैं ?! रूपांतरण प्रयास को ध्यान में रखते हुए।

शायद मैं तो साधारण enum के लिए वापस जाने के रूप में मैं यहाँ का सुझाव दिया: How to use enums as flags in 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); 
} 

Answer 4

असम्पीडित enums के समान वाक्यविन्यास का उपयोग करके काम करने के लिए अपना दूसरा उदाहरण (यानी, एक स्कोप्ड एनम का उपयोग करके) प्राप्त करना संभव है। इसके अलावा, समाधान सामान्य है और सभी स्कोप्ड एनम के लिए काम करेगा, प्रत्येक स्कोप्ड एनम के लिए लेखन कोड बनाम (जैसा कि @ForEveR द्वारा प्रदत्त answer में दिखाया गया है)।

समाधान एक सामान्य operator<< फ़ंक्शन लिखना है जो किसी भी स्कॉम्ड एनम के लिए काम करेगा। समाधान SFINAEstd::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; 
}