C Language
Sprunganweisungen

Syntax

• Rückgabewert; / * Kehrt von der aktuellen Funktion zurück. val kann ein Wert eines beliebigen Typs sein, der in den Rückgabetyp der Funktion konvertiert wird. * /
• Rückkehr; / * Kehrt von der aktuellen Void-Funktion zurück. * /
• brechen; / * Springt unbedingt über das Ende einer Iterationsanweisung (Schleife) oder über die innerste switch-Anweisung. * /
• fortsetzen; / * Springt bedingungslos an den Anfang einer Iterationsanweisung (Schleife). * /
• gehe zu LBL; / * Springt zur Bezeichnung von LBL. * /
• LBL: Anweisung / * eine beliebige Anweisung in derselben Funktion. * /

Bemerkungen

Mit goto aus verschachtelten Schleifen springen

Um aus verschachtelten Schleifen zu springen, müsste normalerweise eine boolesche Variable mit einer Prüfung dieser Variablen in den Schleifen verwendet werden. Angenommen, wir würden über i und j iterieren, könnte es so aussehen

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 */
     }
}   

Die C-Sprache bietet jedoch die goto Klausel, die in diesem Fall nützlich sein kann. Durch die Verwendung eines Labels, das nach den Loops deklariert wurde, können wir die Loops leicht ausbrechen.

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

Wenn jedoch dieses Bedürfnis aufkommt, kann eine return stattdessen besser verwendet werden. Dieses Konstrukt wird auch in der strukturellen Programmiertheorie als "unstrukturiert" betrachtet.

Eine andere Situation, in der goto nützlich sein könnte, ist das Wechseln zu einem Fehlerbehandler:

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;

Die Verwendung von goto hält den Fehlerfluss vom normalen Programmsteuerungsfluss getrennt. Es wird jedoch auch im technischen Sinne als "unstrukturiert" betrachtet.

Verwenden Sie Zurück

Rückgabe eines Wertes

Ein häufig verwendeter Fall: Rückkehr von 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;
}

Zusätzliche Bemerkungen:

1. Für eine Funktion mit einem Rückgabetyp als void (ohne void * oder verwandte Typen) sollte die return keinen zugeordneten Ausdruck haben. dh die einzige erlaubte return-Anweisung wäre return; .

2. Bei einer Funktion mit einem nicht void Rückgabetyp darf die return Anweisung nicht ohne einen Ausdruck erscheinen.

3. Für main() (und nur für main() ) ist keine explizite return Anweisung (in C99 oder höher) erforderlich. Wenn die Ausführung den Abbruch } , wird ein impliziter Wert von 0 zurückgegeben. Einige Leute denken, diese return wegzulassen return ist eine schlechte Praxis. andere schlagen aktiv vor, es wegzulassen.

Nichts zurückgeben

Rückkehr von einer void Funktion

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. */
}

Verwenden Sie break und fahren Sie fort

Lesen Sie continue Lesen bei ungültiger Eingabe oder break auf Benutzeranfrage oder Dateiendung sofort continue :

#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);
  }
}