C Language
Jump-verklaringen

Syntaxis

• terugkeer val; / * Retourneert de huidige functie. val kan een waarde zijn van elk type dat wordt geconverteerd naar het retourtype van de functie. * /
• terug te keren; / * Retourneert van de huidige ongeldige functie. * /
• breken; / * Spring onvoorwaardelijk voorbij het einde ("breekt uit") van een Iteration Statement (lus) of uit de binnenste schakelinstructie. * /
• doorgaan met; / * Springt onvoorwaardelijk naar het begin van een Iteration Statement (lus). * /
• ga naar LBL; / * Springt naar label LBL. * /
• LBL: statement / * elke statement in dezelfde functie. * /

Opmerkingen

Goto gebruiken om uit geneste lussen te springen

Uit geneste lussen springen vereist meestal het gebruik van een booleaanse variabele met een vinkje voor deze variabele in de lussen. Stel dat we itereren over i en j , het zou er zo uit kunnen zien

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

Maar de taal C biedt de goto clausule, die in dit geval nuttig kan zijn. Door het te gebruiken met een label dat achter de lussen wordt aangegeven, kunnen we gemakkelijk uit de lussen breken.

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

Echter, vaak wanneer deze behoefte zich aandient, kan een return beter worden gebruikt. Dit construct wordt ook beschouwd als "ongestructureerd" in de theorie van de structurele programmering.

Een andere situatie waarin goto nuttig kan zijn, is om naar een foutafhandelaar te springen:

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;

Het gebruik van goto houdt de foutstroom gescheiden van de normale programmabesturingsstroom. Het wordt echter ook in technische zin als "ongestructureerd" beschouwd.

Retour gebruiken

Retourneren van een waarde

Een veel gebruikte case: terugkeren van 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;
}

Extra notities:

1. Voor een functie met een retourtype als void (exclusief void * of verwante typen), mag de return geen bijbehorende expressie hebben; dat wil zeggen, het enige toegestane terugkeeroverzicht zou return; .

2. Voor een functie met een niet- void retourtype, wordt de return niet zonder expressie weergegeven.

3. Voor main() (en alleen voor main() ) is een expliciete return niet vereist (in C99 of later). Als de uitvoering het einde bereikt } , wordt een impliciete waarde van 0 geretourneerd. Sommige mensen denken dat het achterwege laten van deze return een slechte gewoonte is; anderen stellen actief voor om het weg te laten.

Niets teruggeven

Terugkeren van een void functie

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

Gebruik pauze en ga door

Ga onmiddellijk continue lezen over ongeldige invoer of break op verzoek van gebruiker of einde bestand:

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