C Language
जम्प स्टेटमेंट्स

वाक्य - विन्यास

• वापसी घाटी; वर्तमान समारोह से / * रिटर्न। वैल किसी भी प्रकार का मान हो सकता है जो फ़ंक्शन के रिटर्न प्रकार में कनवर्ट किया जाता है। * /
• वापसी; / * वर्तमान शून्य-फ़ंक्शन से लौटता है। * /
• टूटना; / * बिना किसी स्टेटमेंट स्टेटमेंट (लूप) के अंत ("ब्रेक आउट") या अंतरतम स्विच स्टेटमेंट से बाहर कूदता है। * /
• जारी रखें; / * बिना किसी कथन कथन (लूप) की शुरुआत में बिना शर्त कूदता है। * /
• गोटो एलबीएल; / * LBL लेबल करने के लिए कूदता है। * /
• एलबीएल: एक ही फ़ंक्शन में स्टेटमेंट / * कोई भी स्टेटमेंट। * /

टिप्पणियों

नेस्टेड छोरों से बाहर निकलने के लिए गोटो का उपयोग करना

नेस्टेड छोरों से बाहर कूदना आमतौर पर छोरों में इस चर के लिए एक चेक के साथ बूलियन चर के उपयोग की आवश्यकता होगी। यह मानकर कि हम i और j पर पुनरावृत्ति कर रहे हैं, यह इस तरह दिख सकता है

size_t i,j;
for (i = 0; i < myValue && !breakout_condition; ++i) {
    for (j = 0; j < mySecondValue && !breakout_condition; ++j) {
        ... /* Do something, maybe modifying breakout_condition */
            /* When breakout_condition == true the loops end */
     }
}   

लेकिन सी भाषा goto क्लॉज प्रदान करती है, जो इस मामले में उपयोगी हो सकती है। छोरों के बाद घोषित लेबल के साथ इसका उपयोग करके, हम आसानी से छोरों को तोड़ सकते हैं।

size_t i,j;
for (i = 0; i < myValue; ++i) {
    for (j = 0; j < mySecondValue; ++j) {
        ...
        if(breakout_condition) 
          goto final;
    }
}
final:

हालांकि, अक्सर जब यह जरूरत return आती है तो return बेहतर इस्तेमाल किया जा सकता है। इस संरचना को संरचनात्मक प्रोग्रामिंग सिद्धांत में "असंरचित" भी माना जाता है।

एक और स्थिति जहां goto उपयोगी हो सकती है वह एक त्रुटि-हैंडलर के लिए कूदने के लिए है:

ptr = malloc(N *  x);
if(!ptr)
  goto out_of_memory;

/* normal processing */
free(ptr);
return SUCCESS;

out_of_memory:
 free(ptr); /* harmless, and necessary if we have further errors */
 return FAILURE;

goto उपयोग त्रुटि प्रवाह को सामान्य प्रोग्राम नियंत्रण प्रवाह से अलग रखता है। हालांकि इसे तकनीकी अर्थ में "असंरचित" भी माना जाता है।

वापसी का उपयोग करना

मान लौटाना

एक आमतौर पर इस्तेमाल किया मामला: main() से लौटकर main()

#include <stdlib.h> /* for EXIT_xxx macros */

int main(int argc, char ** argv)
{
  if (2 < argc)
  {
    return EXIT_FAILURE; /* The code expects one argument: 
                            leave immediately skipping the rest of the function's code */
  }

  /* Do stuff. */

  return EXIT_SUCCESS;
}

अतिरिक्त नोट्स:

1. एक फ़ंक्शन के लिए रिटर्न प्रकार के रूप में void ( void * या संबंधित प्रकार शामिल नहीं), return स्टेटमेंट में कोई संबद्ध अभिव्यक्ति नहीं होनी चाहिए; यानी, केवल स्वीकृत रिटर्न स्टेटमेंट ही रिटर्न होगा return; ।

2. एक गैर- void रिटर्न प्रकार वाले फ़ंक्शन के लिए, return स्टेटमेंट अभिव्यक्ति के बिना दिखाई नहीं देगा।

3. main() और (केवल main() लिए main() (), स्पष्ट return स्टेटमेंट की आवश्यकता नहीं है (C99 या बाद के संस्करण में)। यदि निष्पादन समाप्त हो जाता है } , तो 0 का निहित मूल्य वापस आ जाता है। कुछ लोग सोचते हैं कि इस return को छोड़ना बुरा व्यवहार है; अन्य सक्रिय रूप से इसे छोड़ने का सुझाव देते हैं।

लौटकर कुछ नहीं किया

void फ़ंक्शन से लौट रहा है

void log(const char * message_to_log)
{
  if (NULL == message_to_log)
  {
    return; /* Nothing to log, go home NOW, skip the logging. */
  }

  fprintf(stderr, "%s:%d %s\n", __FILE__, _LINE__, message_to_log);

  return; /* Optional, as this function does not return a value. */
}

ब्रेक का उपयोग करना और जारी रखना

अमान्य इनपुट पर तुरंत पढ़ना continue या उपयोगकर्ता के अनुरोध या फ़ाइल के अंत पर break दें:

#include <stdlib.h> /* for EXIT_xxx macros */
#include <stdio.h>  /* for printf() and getchar() */
#include <ctype.h> /* for isdigit() */

void flush_input_stream(FILE * fp);


int main(void)
{
  int sum = 0;
  printf("Enter digits to be summed up or 0 to exit:\n");

  do
  {
    int c = getchar();
    if (EOF == c)
    {
      printf("Read 'end-of-file', exiting!\n");

      break;
    }

    if ('\n' != c)
    {
      flush_input_stream(stdin);
    }

    if (!isdigit(c))
    {
      printf("%c is not a digit! Start over!\n", c);

      continue;
    }

    if ('0' == c)
    {
      printf("Exit requested.\n");

      break;
    }

    sum += c - '0';

    printf("The current sum is %d.\n", sum);
  } while (1);

  return EXIT_SUCCESS;
}

void flush_input_stream(FILE * fp)
{
  size_t i = 0;
  int c;
  while ((c = fgetc(fp)) != '\n' && c != EOF) /* Pull all until and including the next new-line. */
  {
    ++i;
  }

  if (0 != i)
  {
    fprintf(stderr, "Flushed %zu characters from input.\n", i);
  }
}