C Language
Hoppa uttalanden

Syntax

• returval; / * Återgår från den aktuella funktionen. val kan vara ett värde av vilken typ som helst som konverteras till funktionens returtyp. * /
• lämna tillbaka; / * Återgår från den aktuella tomrumsfunktionen. * /
• ha sönder; / * Hopplöst hoppar bortom slutet ("bryter ut") av ett Iteration-uttalande (slinga) eller ut ur den inre brytaren. * /
• Fortsätta; / * Hopplöst hoppar till början av en Iteration Statement (loop). * /
• goto LBL; / * Hoppar till etiketten LBL. * /
• LBL: uttalande / * varje uttalande i samma funktion. * /

Anmärkningar

Med hjälp av goto för att hoppa ur kapslade öglor

Hoppning från kapslade slingor kräver vanligtvis användning av en boolesisk variabel med en kontroll för denna variabel i slingorna. Antar att vi itererar över i och j , det kan se ut så här

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

Men C-språket erbjuder goto klausulen, som kan vara användbar i det här fallet. Genom att använda den med en etikett som deklareras efter slingorna, kan vi enkelt bryta ur slingorna.

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

Men ofta när detta behov kommer upp skulle en return kunna användas bättre istället. Denna konstruktion betraktas också som "ostrukturerad" i strukturell programmeringsteori.

En annan situation där goto kan vara användbart är att hoppa till en felhanterare:

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;

Användning av goto håller felflödet separat från det normala programstyrflödet. Det anses emellertid också "ostrukturerad" i teknisk mening.

Med retur

Återvända ett värde

Ett vanligt förekommande fall: tillbaka från 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;
}

Ytterligare anmärkningar:

1. För en funktion som har en returtyp som void (exklusive void * eller liknande typer), den return bör uttalande inte ha någon tillhörande uttryck; dvs det enda tillåtna returrättet skulle vara return; .

2. För en funktion som har en icke void returtyp den return skall uttalandet inte visas utan ett uttryck.

3. För main() (och endast för main() ), en uttrycklig return uttalande inte krävs (i C99 eller senare). Om exekveringen når avslutningen } returneras ett implicit värde på 0 . Vissa tycker att det är dåligt att utelämna denna return ; andra föreslår aktivt att lämna det.

Återvända ingenting

Återgå från en 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. */
}

Använd paus och fortsätt

Fortsätt genast continue läsa om ogiltig inmatning eller break på användarbegäran eller filens slut:

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