C Language
Instructions de saut

Syntaxe

• retour val; / * Retourne de la fonction actuelle. val peut être une valeur de tout type qui est convertie en type de retour de la fonction. * /
• revenir; / * Retourne de la fonction void actuelle. * /
• Pause; / * Saute inconditionnellement au-delà de la fin ("saute") d'un relevé d'itération (boucle) ou de la déclaration de commutateur la plus interne. * /
• continuer; / * Saute inconditionnellement au début d'un énoncé d'itération (boucle). * /
• aller à LBL; / * Saute pour étiqueter LBL. * /
• LBL: statement / * toute instruction dans la même fonction. * /

Remarques

Utiliser goto pour sauter des boucles imbriquées

Sauter des boucles imbriquées nécessiterait généralement l'utilisation d'une variable booléenne avec une vérification de cette variable dans les boucles. En supposant que nous parcourons i et j , cela pourrait ressembler à ceci

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

Mais le langage C propose la clause goto , qui peut être utile dans ce cas. En l'utilisant avec une étiquette déclarée après les boucles, nous pouvons facilement sortir des boucles.

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

Cependant, souvent, lorsque ce besoin se présente, un return pourrait être mieux utilisé. Cette construction est également considérée comme "non structurée" dans la théorie de la programmation structurelle.

Une autre situation où goto peut être utile est de sauter à un gestionnaire d'erreur:

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;

L'utilisation de goto permet de garder le flux d'erreur distinct du flux de contrôle de programme normal. Il est toutefois également considéré comme "non structuré" au sens technique.

Utiliser le retour

Retourner une valeur

Un cas couramment utilisé: retour de 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;
}

Notes complémentaires:

1. Pour une fonction ayant un type de retour comme void ( void pas les types void * ou apparentés), l'instruction return ne doit avoir aucune expression associée; c'est-à-dire que la seule déclaration de retour autorisée serait le return; .

2. Pour une fonction ayant un type de retour non void , l'instruction return ne doit pas apparaître sans expression.

3. Pour main() (et uniquement pour main() ), une instruction de return explicite n'est pas requise (en C99 ou version ultérieure). Si l'exécution atteint le terme } , une valeur implicite de 0 est renvoyée. Certaines personnes pensent que l'omission de ce return est une mauvaise pratique; d'autres suggèrent activement de le laisser de côté.

Ne rien retourner

Retourner d'une fonction 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. */
}

Utiliser la pause et continuer

Immédiatement continue la lecture sur l' entrée non valide ou break sur demande de l' utilisateur ou en fin de fichier:

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