C Language
Saltar declaraciones

Sintaxis

• devuelve val; / * Vuelve de la función actual. val puede ser un valor de cualquier tipo que se convierte al tipo de retorno de la función. * /
• regreso; / * Regresa de la función void actual. * /
• descanso; / * Salta incondicionalmente más allá del final ("rompe") de una instrucción de iteración (bucle) o de la instrucción de conmutación más interna. * /
• continuar; / * Salta incondicionalmente al principio de una instrucción de iteración (bucle). * /
• goto LBL; / * Salta para etiquetar LBL. * /
• LBL: declaración / * cualquier declaración en la misma función. * /

Observaciones

Usando goto para saltar fuera de los bucles anidados

Saltar fuera de los bucles anidados normalmente requeriría el uso de una variable booleana con una comprobación de esta variable en los bucles. Suponiendo que estamos iterando sobre i y j , podría verse así

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

Pero el lenguaje C ofrece la cláusula goto , que puede ser útil en este caso. Al usarlo con una etiqueta declarada después de los bucles, podemos romper fácilmente los bucles.

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

Sin embargo, a menudo, cuando surge esta necesidad, una return podría ser mejor utilizada en su lugar. Este constructo también se considera "no estructurado" en la teoría de la programación estructural.

Otra situación en la que goto podría ser útil es para saltar a un manejador de errores:

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;

El uso de goto mantiene el flujo de errores separado del flujo de control del programa normal. Sin embargo, también se considera "no estructurado" en el sentido técnico.

Usando el retorno

Devolviendo un valor

Un caso comúnmente usado: regresar 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;
}

Notas adicionales:

1. Para una función que tenga un tipo de retorno como void (sin incluir los tipos void * o relacionados), la declaración de return no debe tener ninguna expresión asociada; es decir, la única declaración de devolución permitida sería la return; .

2. Para una función que tiene un tipo de retorno no void , la declaración de return no aparecerá sin una expresión.

3. Para main() (y solo para main() ), no se requiere una declaración de return explícita (en C99 o posterior). Si la ejecución alcanza la terminación } , se devuelve un valor implícito de 0 . Algunas personas piensan que omitir este return es una mala práctica; otros sugieren activamente omitirlo.

Devolviendo nada

Volviendo de una función de 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. */
}

Usando break y continue

Inmediatamente continue leyendo en una entrada no válida o break en la solicitud del usuario o al final del archivo:

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