रेंज-आधारित के लिए एनम कक्षाओं के लिए अनुमति दें?

Question

मेरे पास कोड का आवर्ती हिस्सा है जहां मैं enum class के सभी सदस्यों पर लूप करता हूं।

for लूप जो मैं वर्तमान में उपयोग करता हूं, नए range-based for की तुलना में बहुत अवांछित दिखता है।

क्या मेरे वर्तमान for लूप के लिए वर्बोजिटी पर कटौती करने के लिए नई सी ++ 11 सुविधाओं का लाभ उठाने का कोई तरीका है?

वर्तमान कोड है कि मैं सुधार करने के लिए करना चाहते हैं:

enum class COLOR 
{ 
    Blue, 
    Red, 
    Green, 
    Purple, 
    First=Blue, 
    Last=Purple 
}; 

inline COLOR operator++(COLOR& x) { return x = (COLOR)(((int)(x) + 1)); } 

int main(int argc, char** argv) 
{ 
    // any way to improve the next line with range-based for? 
    for(COLOR c=COLOR::First; c!=COLOR::Last; ++c) 
    { 
    // do work 
    } 
    return 0; 
} 

दूसरे शब्दों में, यह अच्छा होगा अगर मैं की तरह कुछ कर सकता है: एक के रूप में शुमार के साथ ही

for(const auto& c : COLOR) 
{ 
    // do work 
} 

Answer 1

पुनरावृत्ति enumerations इटेटरेटर एक खराब विचार है, और मैं deft_code के उत्तर में एक वास्तविक इटरेटर का उपयोग करने की सलाह देता हूं। लेकिन अगर यह सच है क्या आप चाहते हैं:

COLOR operator++(COLOR& x) { return x = (COLOR)(std::underlying_type<COLOR>::type(x) + 1); } 
COLOR operator*(COLOR c) {return c;} 
COLOR begin(COLOR r) {return COLOR::First;} 
COLOR end(COLOR r) {COLOR l=COLOR::Last; return l++;} 

int main() { 
    for(const auto& c : COLOR()) { //note I added parenthesis here to make an instance 
     //do work 
    } 
    return 0; 
} 

यहाँ कार्य करना: http://ideone.com/cyTGD8

---

चीजों की इटरेटर तरफ, सबसे आसान तरीका है बस है:

extern const COLOR COLORS[(int)COLOR::Last+1]; 
const COLOR COLORS[] = {COLOR::Blue, COLOR::Red, COLOR::Green, COLOR::Purple}; 

int main() { 
    for(const auto& c : COLOR()) { //note I added parenthesis here to make an instance 
     //do work 
    } 
    return 0; 
} 

के रूप में यहां देखी गई: http://ideone.com/9XadVt

(सरणी की अलग घोषणा और डिफिंटिनियन इसे एक कंपाइलर त्रुटि बनाता है यदि रंगों की संख्या सरणी में तत्वों की संख्या से मेल नहीं खाती है। उत्कृष्ट आसान सुरक्षित ety जांच)

Answer 2

यहाँ एक परीक्षण किया उदाहरण है (जीसीसी 4.6.1):।

enum class COLOR 
{ 
    Blue, 
    Red, 
    Green, 
    Purple, 
    First=Blue, 
    Last=Purple 
}; 

COLOR operator++(COLOR& x) { return x = (COLOR)(((int)(x) + 1)); } 

COLOR operator*(COLOR c) {return c;} 

COLOR begin(COLOR r) {return COLOR::First;} 
// end iterator needs to return one past the end! 
COLOR end(COLOR r) {return COLOR(int(COLOR::Last) + 1);} 


int main() 
{ 
    for (const auto& color : COLOR()) std::cout << int(color); //
    return 0; 
} 

Answer 3

मैं व्यक्तिगत रूप से enums के लिए ++ ऑपरेटर ओवरलोडिंग पसंद नहीं है। अक्सर वृद्धि एक enum मूल्य वास्तव में समझ में नहीं आता है। जो वास्तव में चाहता था वह enum पर पुनरावृत्ति करने का एक तरीका है।

नीचे एक सामान्य Enum वर्ग है जो पुनरावृत्ति का समर्थन करता है। यह कार्यात्मक लेकिन अपूर्ण है। एक वास्तविक कार्यान्वयन कन्स्ट्रक्टर तक पहुंच प्रतिबंधित करने और सभी इटरेटर लक्षणों को जोड़ने के लिए अच्छा होगा।

#include <iostream> 

template< typename T > 
class Enum 
{ 
public: 
    class Iterator 
    { 
    public: 
     Iterator(int value) : 
     m_value(value) 
     { } 

     T operator*(void) const 
     { 
     return (T)m_value; 
     } 

     void operator++(void) 
     { 
     ++m_value; 
     } 

     bool operator!=(Iterator rhs) 
     { 
     return m_value != rhs.m_value; 
     } 

    private: 
     int m_value; 
    }; 

}; 

template< typename T > 
typename Enum<T>::Iterator begin(Enum<T>) 
{ 
    return typename Enum<T>::Iterator((int)T::First); 
} 

template< typename T > 
typename Enum<T>::Iterator end(Enum<T>) 
{ 
    return typename Enum<T>::Iterator(((int)T::Last) + 1); 
} 

enum class Color 
{ 
    Red, 
    Green, 
    Blue, 
    First = Red, 
    Last = Blue 
}; 

int main() 
{ 
    for(auto e: Enum<Color>()) 
    { 
     std::cout << ((int)e) << std::endl; 
    } 
} 

Answer 4

आप शायद कुछ बढ़ावा :: एमपीएल के साथ चालाक कर सकता है, एक किसी न किसी संस्करण देखने के लिए की तरह हो सकता है:

#include <typeinfo> 

// ---------------------------------------------------------------------------| 
// Boost MPL 
// ---------------------------------------------------------------------------| 
#include <boost/mpl/for_each.hpp> 
#include <boost/mpl/iterator_range.hpp> 
#include <boost/mpl/range_c.hpp> 

namespace mpl = boost::mpl; 

using namespace std; 

enum class COLOR 
{ 
    Blue, 
    Red, 
    Green, 
    Purple, 
    Last 
}; 

struct enumValPrinter 
{ 
    template< typename T > 
    void operator() (const T&) 
    { 
     cout << "enumValPrinter with: " << typeid(T).name() << " : " 
      << T::value << "\n"; 
    } 
}; 

int main(int, char**) 
{ 
    typedef mpl::range_c< int, static_cast<int>(COLOR::Blue), 
          static_cast<int>(COLOR::Last) > Colors; 
    mpl::for_each<Colors>(enumValPrinter()); 
    return 0; 
} 

Answer 5

मैं विचार बहुत पसंद है और अक्सर इसके लिए कामना की है।

समस्या जो मैं देखता हूं वह तब होता है जब एनम आइटम के लिए दोहराए गए संख्यात्मक मूल्य होते हैं। उपर्युक्त सभी कार्यान्वयनों को अभिन्न प्रकार और ++ के लिए आवश्यक है। आखिरकार, मुझे लगता है कि सभी मामलों में प्रत्येक आइटम पर वास्तव में फिर से प्रयास करने के लिए भाषा समर्थन की आवश्यकता हो सकती है। यह पहली, आखिरी या शुरू करने की आवश्यकता को हटा देगा, अंत में हालांकि मैं इस पर बहुत अधिक विरोध नहीं करता हूं। यह कंटेनर के लिए शुरू() अंत() की तलाश में है।

enum class COLOR 
{ 
    Blue, 
    Red, 
    Green, 
    Mauve = 0, 
    Purple, 
    Last 
}; 

माउव में संख्या शुरू हो रही है।

Answer 6

enum class Color { 
    blue, 
    red, 
    green = 5, 
    purple 
}; 
const std::array<Color,4> all_colors = {Color::blue, Color::red, Color::green, Color::purple}; 

तब:

for (Color c : all_colors) { 
    //... 
} 

कई बार मैं इसे इस तरह का उपयोग करें, जहां मैं एक 'कोई नहीं' मूल्य हैं:

// Color of a piece on a chess board 
enum class Color { 
    white, 
    black, 
    none 
}; 
const std::array<Color,3> colors = {Color::white, Color::black}; 

template <typename CONTAINER> 
bool has_item (CONTAINER const & c, typename CONTAINER::const_reference v) { 
    return std::find(c.begin(), c.end(), v) != c.end(); 
} 

bool is_valid (Color c) { 
    return has_item(colors, c) || c == Color::none; 
} 

bool do_it (Color c) { 
    assert(has_item(colors, c)); // here I want a real color, not none 
    // ... 
} 

bool stop_it (Color c) { 
    assert(is_valid(c));   // but here I just want something valid 
    // ... 
} 

Answer 7

आप एक भयानक व्यक्ति को आप प्राप्त कर सकते हैं कर रहे हैं प्रीप्रोसेसर के साथ यह व्यवहार, कुछ:

#include <vector> 
#include <cstdio> 

#define ENUM_NAME COLOR 
#define ENUM_VALUES \ 
    ENUM_VALUE(Blue) \ 
    ENUM_VALUE(Red) \ 
    ENUM_VALUE(Green) \ 
    ENUM_VALUE(Purple) 

// This block would be a #include "make_iterable_enum.h" 
#define ENUM_VALUE(v) v, 
enum class ENUM_NAME {ENUM_VALUES}; 
#undef ENUM_VALUE 
#define ENUM_VALUE(v) ENUM_NAME::v, 
#define VECTOR_NAME(v) values_ ## v 
#define EXPAND_TO_VECTOR_NAME(v) VECTOR_NAME(v) 
const std::vector<ENUM_NAME> EXPAND_TO_VECTOR_NAME(ENUM_NAME){ENUM_VALUES}; 
#undef ENUM_VALUE 
#undef ENUM_NAME 
#undef ENUM_VALUES 
#undef VECTOR_NAME 
#undef EXPAND_TO_VECTOR_NAME 
// end #included block 

int main() { 
    for (auto v : COLOR_values) { 
     printf("%d\n", (int)v); 
    } 
} 

मामूली संशोधन के साथ यह भी समर्थन कर सकता है उदाहरण के लिए। ENUM_SETVALUE (नीला, 4) और उदाहरण से एक कॉन्स मैप बनाना। रंग :: ब्लू टू ब्लू "। और इसके विपरीत।

मेरी इच्छा है कि मानक ने इन सुविधाओं को एनम कक्षा के विकल्प के रूप में बनाया है। कोई भी कामकाज अच्छा नहीं है।

Answer 8

मुझे यकीन है कि आप एक सी ++ initializer_list के सदस्यों से अधिक पुनरावृति कर सकते हैं हूँ, इसलिए मुझे लगता है मैं अतीत में इस किया है:

enum class Color {Red, Green, Blue}; 

for (const Color c : {Color::Red, Color::Green, Color::Blue}) 
{ 
} 

चाहे वहाँ इस के साथ मुद्दों कर रहे हैं, मुझे नहीं पता पता है, लेकिन मैंने सोचा कि मैं इसे संक्षिप्त मानता हूं क्योंकि यह संक्षिप्त है, लेकिन बहुत सारे रंग होने पर आदर्श नहीं है।