उद्देश्य-सी में स्विच स्टेटमेंट में मैं गोटो का उपयोग कैसे कर सकता हूं?

Question

मेरे कोड में मुझे एक ही स्विच स्टेटमेंट में एक अलग केस कूदने (गोटो) करने में सक्षम होना चाहिए। क्या इसे करने का कोई तरीका है?

मेरे कोड कुछ इस तरह है:

switch (viewNumber) { 
case 500: 
     // [...] 
break; 

case 501: 
     // [...] 
break; 
. 
. 
. 
. 
. 

case 510: 
     // [...] 
break; 

default: 
break; 

}

अपने समय के लिए धन्यवाद (वहाँ कोड का एक बहुत मैं बस यह सब बाहर छोड़ दिया है)! -जेफ

Answer 1

आमतौर पर बहुत खराब अभ्यास बिना शर्त रूप से कूदने के लिए आप पूछ रहे हैं।

मुझे लगता है कि एक और पठनीय/रखरखाव समाधान एक विधि में साझा कोड रखना होगा और कई मामलों में विधि को कॉल करना होगा।

आप वास्तव में के लिए, आप goto उपयोग कर सकते हैं की तरह कुछ करने के लिए करना चाहते हैं:

switch(viewNumber) { 
    case 500: 
     // [...] 
     goto jumpLabel; 
    case 501: 
     // [...] 
     break; 
    case 502: 
     // [...] 
     jumpLabel: 
     // Code that 500 also will execute 
     break; 
    default:break; 
} 

नोट: मैं केवल कोड उपरोक्त उदाहरण आपके प्रश्न का उत्तर के लिए प्रदान की। अब मैं बहुत गंदा महसूस करता हूं मुझे कुछ Bad Code Offsets खरीदना पड़ सकता है।

Answer 2

आपको शायद अपने कोड को फिर से लिखना चाहिए, जैसे रिकर्सिव कॉल या सामान्य सामान को कारक करना और एक अलग फ़ंक्शन कॉल करना। लेकिन एक फिक्स और अपने प्रश्न का त्वरित जवाब के रूप में आप तो

switchLabel: 
switch(viewNumber) { 
    case 500: { 
    viewNumber = 501; 
    goto switchLabel; 
    } 
} 

ऑब्जेक्टिव-सी वाक्य रचना यहाँ के बारे में सुनिश्चित नहीं की तरह अपने स्विच से पहले एक लेबल डाल सकता है और गोटो यह, है, लेकिन आप भी

उसके एक बदलाव की कोशिश कर सकते

int lastView = 0; 

while (lastView != viewNumber) 
    switch(lastView = viewNumber) { 
    case 500: { 
     viewNumber = 501; 
     break; 
    } 
    } 

जो दृश्य तक लूपिंग जारी रखेगा नम्बर अब और नहीं बदलता है। यद्यपि यह अभी भी एक सुंदर दिखने वाला गोटो है।

और चूंकि हम गेटोस कर रहे हैं, तो आप पहले से ही बताए गए एक और मामले में जा सकते हैं। आप अन्य ब्लॉकों के अंदर मामलों को डालकर, डफ के डिवाइस की तरह फैंसी सामान भी कर सकते हैं। लेकिन यह सिर्फ पागल है .. :)

Answer 3

goto का उपयोग करने के बजाय, अपने कोड को दोबारा दोहराएं ताकि सामान्य कोड का उपयोग करने वाले दो (या अधिक) मामले इसे सामान्य विधि में बुला सकें।

कुछ की तरह:

switch (value) { 
    case (firstValue): 
     // ... 
     break; 
    case (secondValue): 
     [self doSharedCodeForSecondAndThirdValues]; 
     break; 
    case (thirdValue): 
     [self doSharedCodeForSecondAndThirdValues]; 
     break; 
    default: 
     break; 
} 

// ... 

- (void) doSharedCodeForSecondAndThirdValues { 
    // do stuff here that is common to second and third value cases 
} 

यह दुनिया के अंत goto उपयोग करने के लिए नहीं होगा, हालांकि यह बुरा व्यवहार है।

goto के उपयोग से बचने का व्यावहारिक कारण यह है कि आपको goto लेबल खोजने के लिए अपने swtich-case पेड़ से खोजना होगा।

यदि आपका स्विच तर्क बदलता है, तो आपके हाथों पर एक गन्दा स्थिति होगी।

यदि आप अपनी विधि में सामान्य कोड खींचते हैं, तो कोड को पढ़ने, डीबग और विस्तार करना आसान होता है।

Answer 4

[मैं इस सवाल का जवाब समुदाय विकी बना रहा हूं क्योंकि यह वास्तव में इस सवाल का जवाब नहीं है दर असल]

के रूप में अन्य लोगों ने कहा, यह बहुत बुरा शैली है, और अपठनीय कोड के लिए बनाता है ...

विकल्प:

1. फैक्टर एक अलग समारोह में आम कोड और कॉल कि 2 स्थानों में।
2. गिरावट का उपयोग करें, किसी मामले पर ब्रेक को छोड़ दें और यह अगले के माध्यम से हो जाता है (याद रखें, मामलों को संख्यात्मक क्रम में नहीं होना चाहिए!)
3. यदि आप केवल एक मामले का हिस्सा चाहते हैं

case 500: 
. 
. 
. 
case 501: 
    if(viewNumber == 501) { 
    . 
    . 
    . 
    } 
    . 
    . 
    . 
    break;