Enum scoping मुद्दों

Question

मैं संभव के रूप में स्थानीय रूप में चीजों को रखने की कोशिश, तो मैं वर्ग दायरे में enums डाल, भले ही वे दो वर्गों (मैं इसे कक्षा में डाल दिया है कि यह साथ "बेहतर हो जाता है"।) यह है के बीच साझा कर रहे हैं बहुत अच्छा काम किया, लेकिन मैंने हाल ही में एक ऐसे मुद्दे में भाग लिया जहां एक गोलाकार निर्भरता तब होगी जब मैं कक्षा के दायरे में enum डाल दिया।

enum कई वर्गों के लिए एक निर्माता तर्क होने जा रहा है, और कक्षा में है (और वर्ग है कि ज्यादातर समझ में आता है उस में होने के लिए) उन वर्गों में शामिल हैं। इस प्रकार, कक्षाओं के लिए कन्स्ट्रक्टर तर्क के रूप में enum का उपयोग करना संभव नहीं है क्योंकि इसका परिणाम गोलाकार निर्भरता में होगा।

बेहतर होगा सिर्फ अपने हेडर फाइल में इस enum डाल करने के लिए, और यदि ऐसा है तो, मैं हेडर फाइल में enums के सभी रखना चाहिए एक समान होना चाहिए? क्या इस मुद्दे के लिए कोई अन्य समाधान हैं (जो तार्किक हैं)?

Answer 1

अगर enum कई वर्गों द्वारा किया जाता है तो मैं कहूंगा कि यह वास्तव में एक भी वर्ग की परिभाषा में लेकिन नाम स्थान में नहीं है जिसमें वे वर्ग रहते हैं।

यह तब तक है जब तक कि एक वर्ग के माध्यम से एक वर्ग के माध्यम से गणना को पारित नहीं किया जा रहा है, इस मामले में यह enum निर्भर वर्ग को तुरंत चालू करने और इसे कक्षा के निर्माता के पैरामीटर के रूप में पास करने के लिए और अधिक समझ सकता है।

Answer 2

आप इस तरह enum की घोषणा अग्रेषित करने के लिए कोशिश कर सकते हैं:

enum MyEnum; 

Answer 3

आप किसी भी वर्ग करता है, तो उसे साझा किया के बाहर enum जगह चाहिए, लेकिन आप अभी भी enum गुंजाइश कर सकते हैं। यह नाम स्थान में रखें तो प्रगणक "रिसाव" नहीं करते हैं, अपनी परियोजना के नाम स्थान को अव्यवस्थित:

namespace Project { // you already have this, right? :) 
    namespace COLOR { // naming styles differ, use what you like 
    enum Color { 
     red, 
     green, 
     blue 
    }; 
    } 
    using COLOR::Color; // now you can use the type 'normally' 

    // examples: 
    struct A { 
    Color c; 
    A() : c(COLOR::red) {} 
    }; 
    void f(Color c) { 
    using namespace COLOR; 
    // inside this function, we no longer have to prefix COLOR:: 
    if (c == green) { 
     go(); 
    } 
    else if (c == red) { 
     stop(); 
    } 
    } 
} 

Answer 4

मैं अक्सर एक नाम स्थान में मेरे enums डाल ग्लोबल नेम स्पेस को अव्यवस्थित से विभिन्न enum मूल्यों को रोकने के लिए। मुझे लगता है कि आप उन्हें कक्षा में डालकर क्या करने की कोशिश कर रहे हैं। लेकिन अगर वे 'फिट' नहीं अच्छी तरह से एक कक्षा में, एक namespace इस उद्देश्य के लिए काफी अच्छी तरह से बस के रूप में काम करता है:

namespace FooSettings 
{ 
    enum FooSettings 
    { 
     foo, 
     bar 
    }; 
} 
typedef enum FooSettings::FooSettings FooSettingsEnum; 


int main() 
{ 
    FooSettingsEnum x = FooSettings::foo; 
}; 

मैं एक संपादक का टुकड़ा है जो दिए गए एक नए गणन के लिए रूपरेखा बस नाम है बनाता है ,

typedef enum FooSettings::FooSettings FooSettingsEnum; 

लाइन है कि एक typedef बनाता है तो यह एक बालक अधिक पठनीय गणन के प्रकार के साथ चर घोषित करने के लिए है भी शामिल है।

मुझे संदेह है कि स्ट्राउस्ट्रप ने गणना के लिए गणित मूल्य नाम बनाए होंगे यदि उसके पास अवसर था, लेकिन सी संगतता ने अपना हाथ मजबूर कर दिया (यह सिर्फ अटकलें है - शायद एक दिन मैं डी & ई में देखूंगा और देख सकता हूं अगर वह कुछ भी उल्लेख करता है)।

Answer 5

मैं क्या माइकल और रोजर कर का एक संस्करण का उपयोग करें:

namespace Color 
{ 
    enum Type 
    { 
     red, 
     green, 
     blue 
    }; 
}; 

void paintHouse(Color::Type color) {...} 

main() 
{ 
    paintHouse(Color::red); 
} 

मैं Color::Type लगता है Color::Color या COLOR::Color से खूबसूरत और अधिक आत्म दस्तावेज़ीकृत किया जाना है। यदि आपको Color::Type भी वर्बोज़ मिलता है, तो आप Color::T का उपयोग कर सकते हैं।

मैं अपने गणित मूल्यों का उपसर्ग नहीं करता (यानी COLOR_RED) क्योंकि enum के आसपास नामस्थान प्रभावी ढंग से उपसर्ग बन जाता है।

मैंने अपने स्कॉप्ड स्थिरांक के लिए ALL_CAPS सम्मेलन का उपयोग करना बंद कर दिया है क्योंकि वे सी पुस्तकालयों (उदाहरण के लिए NULL) में मैक्रोज़ के साथ संघर्ष करते हैं। मैक्रो नामस्थान वे में परिभाषित कर रहे हैं में scoped नहीं कर रहे हैं

Answer 6

सी ++ 11 के बाद से, आप एक enum class उपयोग कर सकते हैं। (या enum struct - एक ही बात अलग घोषित), जहां enum मूल्यों enum के नाम के scoped रहे हैं । उदाहरण के लिए, यहां एक मान्य सी ++ 11 घोषणा है।

enum class token_type { 
    open_paren, 
    close_paren, 
    identifier 
}; 

enum के मूल्यों पर पहुंचने के लिए, हालांकि, आप गुंजाइश इसे सही ढंग से :: ऑपरेटर का उपयोग करना होगा। इसलिए, इस सी ++ 11 में एक वैध काम है:

token_type type = token_type::close_paren; 

लेकिन यह नहीं है:

token_type type = close_paren; 

यह नामकरण संघर्ष को हल करती है, और इसका मतलब है आप कंटेनर नाम स्थान का उपयोग करने की जरूरत नहीं या केवल उन मूल्यों के दायरे को रोकने के लिए संरचना जहां उन्हें नहीं करना चाहिए। इसका मतलब है कि निम्नलिखित enum token_type रूप में एक ही दायरे में मौजूद कर सकते हैं:

enum class other_enum { 
    block, 
    thingy, 
    identifier 
}; 

अब दो मानों दो अलग structs में identifier बुलाया हस्तक्षेप नहीं करेगा।

Answer 7

मैं एमिले से सहमत हूं। के रूप में

struct Color 
{ 
    enum Type 
    { 
    red, 
    green, 
    blue 
    }; 
}; 

इस प्रकार मैं आदर्श के बाद से यह पसंद करते हैं मैं एक नाम स्थान का प्रयोग करेंगे एक मॉड्यूल है कि कई वर्गों में शामिल है का प्रतिनिधित्व करने के बजाय सिर्फ देखते हुए एक अन्य विकल्प यदि आप सी ++ 98 उपयोग कर रहे हैं, नाम स्थान के बजाय struct उपयोग करने के लिए है एक enum ...