C++ => गणना

मूल गणना घोषणा

मानक गणनाएं उपयोगकर्ताओं को पूर्णांकों के सेट के लिए एक उपयोगी नाम घोषित करने की अनुमति देती हैं। नामों को सामूहिक रूप से प्रगणक के रूप में जाना जाता है। एक एन्यूमरेशन और उससे जुड़े एन्यूमरेटर्स को निम्नानुसार परिभाषित किया गया है:

enum myEnum
{
    enumName1,
    enumName2,
};

एक गणना एक प्रकार है , जो अन्य सभी प्रकारों से अलग है। इस मामले में, इस प्रकार का नाम myEnum । इस प्रकार की वस्तुओं से गणना के भीतर एक एन्यूमरेटर के मूल्य को मानने की उम्मीद की जाती है।

प्रगणक के भीतर घोषित किए गए प्रगणक गणना के प्रकार के निरंतर मान हैं। हालांकि एनुमरेटर्स प्रकार के भीतर घोषित किए जाते हैं, लेकिन गुंजाइश ऑपरेटर :: नाम तक पहुंचने के लिए आवश्यक नहीं है। तो पहले एन्यूमरेटर का नाम enumName1 ।

सी ++ 11

गुंजाइश ऑपरेटर वैकल्पिक रूप से एक गणना के भीतर एक एन्यूमरेटर तक पहुंचने के लिए उपयोग किया जा सकता है। तो enumName1 को भी enumName1 जा सकता है myEnum::enumName1 ।

Enumerators को पूर्णांक मान दिए गए हैं जो 0 से शुरू हो रहा है और एक गणना में प्रत्येक एन्यूमरेटर के लिए 1 से बढ़ रहा है। तो उपरोक्त मामले में, enumName1 का मान 0 है, जबकि enumName2 का मान 1 है।

Enumerators को उपयोगकर्ता द्वारा एक विशिष्ट मूल्य भी सौंपा जा सकता है; यह मान एक अभिन्न स्थिर अभिव्यक्ति होना चाहिए। ऐसे एन्यूमरेटर जिनके मूल्य स्पष्ट रूप से प्रदान नहीं किए गए हैं, उनका मान पिछले एन्यूमरेटर + 1 के मान पर सेट होगा।

enum myEnum
{
    enumName1 = 1, // value will be 1
    enumName2 = 2, // value will be 2
    enumName3,     // value will be 3, previous value + 1
    enumName4 = 7, // value will be 7
    enumName5,     // value will be 8
    enumName6 = 5, // value will be 5, legal to go backwards
    enumName7 = 3, // value will be 3, legal to reuse numbers
    enumName8 = enumName4 + 2, // value will be 9, legal to take prior enums and adjust them
};

स्विच स्टेटमेंट में गणना

प्रगणकों के लिए एक सामान्य उपयोग स्विच स्टेटमेंट के लिए है और इसलिए वे आमतौर पर राज्य मशीनों में दिखाई देते हैं। वास्तव में गणना के साथ स्विच स्टेटमेंट की एक उपयोगी विशेषता यह है कि यदि स्विच के लिए कोई डिफ़ॉल्ट स्टेटमेंट शामिल नहीं है, और एनम के सभी मूल्यों का उपयोग नहीं किया गया है, तो कंपाइलर एक चेतावनी जारी करेगा।

enum State {
    start,
    middle,
    end
};

...

switch(myState) {
    case start:
       ...
    case middle:
       ...
} // warning: enumeration value 'end' not handled in switch [-Wswitch]

एक एनम पर Iteration

एन्यूमरेशन को लेकर कोई अंतर्निहित नहीं है।

लेकिन कई तरीके हैं

केवल निरंतर मूल्यों वाले enum लिए:

enum E {
    Begin,
    E1 = Begin,
    E2,
    // ..
    En,
    End
};

for (E e = E::Begin; e != E::End; ++e) {
    // Do job with e
}

सी ++ 11

enum class साथ, operator ++ को लागू करना होगा:

E& operator ++ (E& e)
{
    if (e == E::End) {
        throw std::out_of_range("for E& operator ++ (E&)");
    }
    e = E(static_cast<std::underlying_type<E>::type>(e) + 1);
    return e;
}

std::vector रूप में एक कंटेनर का उपयोग करना

enum E {
    E1 = 4,
    E2 = 8,
    // ..
    En
};

std::vector<E> build_all_E()
{
    const E all[] = {E1, E2, /*..*/ En};
    
    return std::vector<E>(all, all + sizeof(all) / sizeof(E));
}

std::vector<E> all_E = build_all_E();

और फिर

for (std::vector<E>::const_iterator it = all_E.begin(); it != all_E.end(); ++it) {
    E e = *it;
    // Do job with e;
}

सी ++ 11

या std::initializer_list और एक सरल वाक्यविन्यास:

enum E {
    E1 = 4,
    E2 = 8,
    // ..
    En
};

constexpr std::initializer_list<E> all_E = {E1, E2, /*..*/ En};

और फिर

for (auto e : all_E) {
    // Do job with e
}

बंद हो गई दुश्मनी

C ++ 11 यह दर्शाता है कि स्कोप्ड एनम के रूप में क्या जाना जाता है। ये ऐसे एन्यूमरेशन हैं जिनके सदस्यों को enumname::membername साथ योग्य होना चाहिए enumname::membername । एनोप enum class सिंटैक्स का उपयोग करके स्कोप किए गए एनम को घोषित किया जाता है। उदाहरण के लिए, इंद्रधनुष में रंगों को संग्रहीत करने के लिए:

enum class rainbow {
    RED,
    ORANGE,
    YELLOW,
    GREEN,
    BLUE,
    INDIGO,
    VIOLET
};

विशिष्ट रंग तक पहुँचने के लिए:

rainbow r = rainbow::INDIGO;

enum class es को बिना किसी कलाकार के int s में परिवर्तित किया जा सकता है। तो int x = rainbow::RED अमान्य है।

स्कूप्ड एनम भी आपको अंतर्निहित प्रकार को निर्दिष्ट करने की अनुमति देता है, जो कि किसी सदस्य का प्रतिनिधित्व करने के लिए उपयोग किया जाने वाला प्रकार है। डिफ़ॉल्ट रूप से यह int । टिक-टैक-टो खेल में, आप इस टुकड़े को स्टोर कर सकते हैं

enum class piece : char {
    EMPTY = '\0',
    X = 'X',
    O = 'O',
};

जैसा कि आप देख सकते हैं, enum एस अंतिम सदस्य के बाद एक अल्पविराम अल्पविराम हो सकता है।

C ++ 11 में आगे की घोषणा की

बंद गणना:

...
enum class Status; // Forward declaration 
Status doWork(); // Use the forward declaration
...
enum class Status { Invalid, Success, Fail };
Status doWork() // Full declaration required for implementation
{
    return Status::Success;
}

अघोषित गणनाएँ:

...
enum Status: int; // Forward declaration, explicit type required
Status doWork(); // Use the forward declaration
...
enum Status: int{ Invalid=0, Success, Fail }; // Must match forward declare type
static_assert( Success == 1 );

एक इन-डेप्थ मल्टी-फाइल उदाहरण यहां पाया जा सकता है: ब्लाइंड फ्रूट मर्चेंट उदाहरण

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

C++
गणना

खोज…

मूल गणना घोषणा

स्विच स्टेटमेंट में गणना

एक एनम पर Iteration

बंद हो गई दुश्मनी

C ++ 11 में आगे की घोषणा की