क्या एक स्विच स्टेटमेंट में निम्नलिखित करना संभव है - सी ++?

Question

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

मेरा प्रश्न यह है:

क्या यह संभव है स्विच बयान में बूलियन की स्थिति है?

उदाहरण:

switch(userInputtedInt) 
{ 
    case >= someNum && <= someOtherNum 
    break; 
    // Is this possible? 
} 

Answer 1

कोई इस सी में संभव नहीं है ++। स्विच स्टेटमेंट केवल सरल पूर्णांक मैचों का समर्थन करते हैं। आप एक जटिल बूलियन हालत की जरूरत है तो आप अगर/बाकी

Answer 2

ब्लॉक /////////////// नहीं

Answer 3

यह संभव नहीं है एक का उपयोग करना चाहिए। सबसे नज़दीकी आप कुछ कर सकते हैं, यदि मूल्य उचित रूप से एक साथ बंद हैं

switch(userInputtedInt) 
{ 
    case someNum: 
    case someNum+1: 
    // ... 
    case someOtherNum: 
    break; 

} 

Answer 4

सी ++ इसका समर्थन नहीं करता है।

हालांकि, अगर आप पोर्टेबल, मानक कोड लिखने के साथ संबंध नहीं कर रहे हैं कुछ compilers इस विस्तारित वाक्य रचना का समर्थन:

switch(userInputtedInt) 
{ 
    case someNum...someOtherNum: 
    break; 
} 

उन मूल्यों निरंतर होना चाहिए।

if ((userInputtedInt >= someNum) && (userInputtedInt <= someOtherNum)) { ... } 

बेशक

, आप एक switch बयान में कि शामिल कर सकते हैं:

Answer 5

नहीं, यह आमतौर पर if बयान के दायरे है

switch (x) { 
    case 1: 
     // handle 1 
     break; 
    default: 
     if ((x >= 2) && (x <= 20)) { ... } 
} 

Answer 6

यह सीधे संभव नहीं है - एक सी या सी ++ स्विच स्टेटमेंट की आवश्यकता है कि प्रत्येक मामला निरंतर है, बूलियन अभिव्यक्ति नहीं। यदि आपने समान रूप से वितरित श्रेणियां वितरित की हैं, तो आप अक्सर पूर्णांक विभाजन का उपयोग कर एक ही प्रभाव प्राप्त कर सकते हैं। जैसे यदि आपके पास 1 से 100 के इनपुट हैं, और 90-100 के साथ एक समूह के रूप में काम करना चाहते हैं, 80-89 किसी अन्य समूह के रूप में काम करना चाहते हैं, और इसी तरह, आप अपना इनपुट 10 तक विभाजित कर सकते हैं, और प्रत्येक परिणाम एक सीमा का प्रतिनिधित्व करेगा।

Answer 7

जैसा कि अन्य ने कहा है कि आप इस को सीधे लागू नहीं कर सकते हैं क्योंकि आप ऐसा करने का प्रयास कर रहे हैं क्योंकि C++ वाक्यविन्यास इसे अनुमति नहीं देता है। लेकिन आप यह कर सकते हैं:

switch(userInputtedInt) 
{ 
    // case 0-3 inclusve 
    case 0 : 
    case 1 : 
    case 2 : 
    case 3 : 
    // do something for cases 0, 1, 2 & 3 
    break; 

    case 4 : 
    case 5 : 
    // do something for cases 4 & 5 
    break; 
} 

Answer 8

आप पूर्वप्रक्रमक कल्पना यदि आप मैक्रो किसी तरह की आवश्यकता मामले बयान की संख्या है कि ऑटो का विस्तार लिख सकते हैं। हालांकि, बहुत अधिक केस स्टेटमेंट्स के साथ एक लंबी फ़ाइल की आवश्यकता होगी (उदा: #define CASE0 केस 0: # परिभाषित करें CASE1 केस 1: ...)

आपको वहां जाना नहीं चाहिए लेकिन यह करना मजेदार है ... मजे के लिए! ;)

Answer 9

या आप शायद इस

switch((userInputtedInt >= someNum) && (userInputtedInt <= someOtherNum)) 
{ 
case true: 
    //do something 
    break; 
case false: 
    //something else 
    break; 
} 

कर सकते हैं लेकिन यह सिर्फ नीचे-दाएं भयानक प्रोग्रामिंग है कि अगर-किसी और बयानों के साथ संभाला जा सकता है है।

Answer 10

मानक इस के लिए अनुमति नहीं देता:

6.4.2 स्विच बयान [stmt.switch]

[...] स्विच बयान के भीतर किसी भी बयान से एक के साथ लेबल किया जा सकता या अधिक मामले इस प्रकार के रूप में इंगित:

case constant-expression :

जहां निरंतर अभिव्यक्ति एक अभिन्न निरंतर अभिव्यक्ति (5.19) होगा।

Answer 11

कुछ सी ++ कंपाइलर आज भी वाक्यविन्यास का समर्थन करते हैं - इस सवाल के मूल रूप से 8 साल बाद पूछा गया था। यह मुझे आश्चर्यचकित करता है।

मैंने 2012 में पास्कल सीखा, पास्कल के पास सीमाएं हैं। फिर कुछ ने मुझे सी ++ के साथ समान वाक्यविन्यास का प्रयास करने के लिए प्रोत्साहित किया, फिर यह अप्रत्याशित रूप से शानदार काम करता है।

संकलक अपने लैपटॉप पर छ है ++ (जीसीसी) 6.4.0 (Cygwin परियोजना से) एसटीडी = C++ 17

एक काम उदाहरण है, जो मैं जल्दी में लिखा है। repl.it

इसके अलावा, स्रोत कोड का पालन जुड़ा हुआ है:

#include <iostream> 
using namespace std; 
#define ok(x) cout << "It works in range(" << x << ")" << endl 
#define awry cout << "It does\'t work." << endl 

int main() { 
    /*bool a, b, c, d, e, f, g; 
    switch(true) { 
     case (a): break;   These does not work any more... 
     case (b and c): break; 
    }*/ 
    char ch1 = 'b'; 
    switch(ch1) { 
     case 'a' ... 'f': ok("a..f"); break; 
     case 'g' ... 'z': ok("g..z"); break; 
     default: awry; 
    } 
    int int1 = 10; 
    switch(int1) { 
     case 1 ... 10: ok("1..10"); break; 
     case 11 ... 20: ok("11..20"); break; 
     default: awry; 
    } 

    return 0; 
}