declaración de retorno vs salida () en main ()

¿Debo usar exit()o solo returndeclaraciones en main()? Personalmente, estoy a favor de las returndeclaraciones porque siento que es como leer cualquier otra función y el control de flujo cuando leo el código es fluido (en mi opinión). E incluso si quiero refactorizar la main()función, tener returnparece ser una mejor opción que exit().

¿Hace exit()algo especial que returnno lo hace?

En realidad, no es una diferencia, pero es sutil. Tiene más implicaciones para C ++, pero las diferencias son importantes.

Cuando llamo , se llamarán returna los main()destructores para mis objetos de ámbito local. Si llamo exit(), no se llamará a destructor para mis objetos localmente alcanzados. Vuelve a leer eso. exit() no vuelve . Eso significa que una vez que lo llamo, no hay "backsies". Los objetos que haya creado en esa función no serán destruidos. A menudo esto no tiene implicaciones, pero a veces lo hace, como cerrar archivos (¿seguramente desea que todos sus datos se vacíen en el disco?).

Tenga en cuenta que los staticobjetos se limpiarán incluso si llama exit(). Finalmente tenga en cuenta que si usa abort(), no se destruirán objetos. Es decir, no se llamarán a sus destructores objetos globales, objetos estáticos ni objetos locales.

Proceda con precaución al favorecer la salida sobre el retorno.

http://groups.google.com/group/gnu.gcc.help/msg/8348c50030cfd15a

Otra diferencia: exites una función de biblioteca estándar, por lo que debe incluir encabezados y enlaces con la biblioteca estándar. Para ilustrar (en C ++), este es un programa válido:

int main() { return 0; }

pero para usar exitnecesitarás incluir:

#include <stdlib.h>
int main() { exit(EXIT_SUCCESS); }

Además, esto agrega una suposición adicional: que llamar exitdesde maintiene los mismos efectos secundarios que devolver cero. Como otros han señalado, esto depende de qué tipo de ejecutable esté construyendo (es decir, quién llama main). ¿Estás codificando una aplicación que usa el tiempo de ejecución C? ¿Un complemento maya? ¿Un servicio de Windows? ¿Un conductor? Cada caso requerirá investigación para ver si exites equivalente a return. En mi humilde opinión, usar exitcuando realmente te refieresreturn solo hace que el código sea más confuso. OTOH, si realmente quieres decirexit , entonces utilízalo .

Hay al menos una razón para preferir exit: si alguno de sus atexitcontroladores se refiere a datos de duración de almacenamiento automático main, o si usó setvbufo setbufasignó a una de las transmisiones estándar un búfer de duración de almacenamiento automático main, luego regresa de mainproduce comportamiento indefinido, pero la llamada exites válida.

Sin embargo, otro uso potencial (generalmente reservado para programas de juguetes) es salir de un programa con invocaciones recursivas de main.

Siempre uso returnporque el prototipo estándar para main()dice que devuelve un int.

Dicho esto, algunas versiones de los estándares dan mainun tratamiento especial y suponen que devuelve 0 si no hay una returndeclaración explícita . Dado el siguiente código:

int foo() {}
int main(int argc, char *argv[]) {}

G ++ solo genera una advertencia foo()e ignora el retorno faltante de main:

% g++ -Wall -c foo.cc
foo.cc: In function ‘int foo()’:
foo.cc:1: warning: control reaches end of non-void function

I ENÉRGICAMENTE segundo el comentario de R. acerca del uso de la salida () con el fin de evitar tener almacenamiento automático en main()recuperada antes de que el programa realmente extremos. Una return X;declaración en main()no es exactamente equivalente a una llamada a exit(X);, ya que el almacenamiento dinámico de main()desaparece cuando main()regresa, pero no desaparece si se realiza una llamada a exit().

Además, en C o en cualquier lenguaje similar a C, una returndeclaración sugiere al lector que la ejecución continuará en la función de llamada, y si bien esta continuación de la ejecución suele ser técnicamente cierta si cuenta la rutina de inicio de C que llamó a su main()función, no es exactamente lo que quieres decir cuando quieres terminar el proceso.

Después de todo, si usted desea terminar su programa desde cualquier otra función, excepto main()que debe llamar exit(). Hacerlo de manera consistente main()también hace que su código sea mucho más legible, y también hace que sea mucho más fácil para cualquiera volver a factorizar su código; es decir, el código copiado de main()alguna otra función no se comportará mal debido a returndeclaraciones accidentales que deberían haber sido exit()llamadas.

Entonces, combinando todos estos puntos, la conclusión es que es un mal hábito , al menos para C, usar una returndeclaración para finalizar el programa main().

¿Exit () hace algo especial que 'return' no?

Con algunos compiladores para plataformas poco comunes, exit()podría traducir su argumento al valor de salida de su programa, mientras que un retorno de main()podría simplemente pasar el valor directamente al entorno host sin ninguna traducción.

El estándar requiere un comportamiento idéntico en estos casos (específicamente, dice que devolver algo que sea intcompatible main()debería ser equivalente a llamar exit()con ese valor). El problema es que diferentes sistemas operativos tienen diferentes convenciones para interpretar los valores de salida. En muchos sistemas (¡MUCHOS!), 0 significa éxito y cualquier otra cosa es un fracaso. Pero en, por ejemplo, VMS, los valores impares significan éxito y los pares significan fracaso. Si devolvió 0 desde main(), un usuario de VMS vería un mensaje desagradable sobre una infracción de acceso. En realidad no hubo una infracción de acceso, ese fue simplemente el mensaje estándar asociado con el código de falla 0.

Luego, ANSI apareció y fue bendecido EXIT_SUCCESSy EXIT_FAILUREcomo argumentos a los que podrías pasar exit(). La norma también dice que exit(0)debe comportarse de forma idéntica a exit(EXIT_SUCCESS), por lo que la mayoría de las implementaciones definen EXIT_SUCCESSa 0.

El estándar, por lo tanto, lo pone en un enlace en VMS, ya que no deja una forma estándar de devolver un código de falla que tiene el valor 0.

El compilador VAX / VMS C de principios de la década de 1990, por lo tanto, no interpretó el valor de retorno main(), simplemente devolvió cualquier valor al entorno host. Pero si lo usara exit(), haría lo que el estándar requería: traducir EXIT_SUCCESS(o 0) en un código de éxito y EXIT_FAILUREen un código de falla genérico. Para usarlo EXIT_SUCCESS, tenía que pasárselo exit(), no podía devolverlo main(). No sé si las versiones más modernas de ese compilador conservaron ese comportamiento.

Un programa C portátil solía verse así:

#include <stdio.h>
#include <stdlib.h>

int main() {
  printf("Hello, World!\n");
  exit(EXIT_SUCCESS);  /* to get good return value to OS */
  /*NOTREACHED*/ /* to silence lint warning */
  return 0;  /* to silence compiler warning */
}

Aparte: si recuerdo correctamente, la convención VMS para valores de salida tiene más matices que impar / par. En realidad, usa algo como los tres bits bajos para codificar un nivel de gravedad. En términos generales, sin embargo, los niveles de gravedad impares indicaron éxito o información variada y los pares indicaron errores.

En C regresar de maines exactamente lo mismo que llamar exitcon el mismo valor.

La sección 5.1.2.2.3 de los estados estándar de C :

Si el tipo de retorno de la función principal es un tipo compatible con int, un retorno de la llamada inicial a la función principal es equivalente a llamar a la función de salida con el valor devuelto por la función principal como argumento ; 11) alcanzar el} que finaliza la función principal devuelve un valor de 0. Si el tipo de retorno no es compatible con int, el estado de terminación devuelto al entorno host no está especificado.

Las reglas para C ++ son un poco diferentes como se menciona en otras respuestas.

En realidad, existe una diferencia entre exit(0)y return(0)en main- cuando su mainfunción se llama varias veces.

El siguiente programa

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {
  if (argc == 0)
    return(0);
  printf("%d", main(argc - 1, argv));
}

Correr como

./program 0 0 0 0

Resultará en la siguiente salida:

00000

Sin embargo este:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {
  if (argc == 0)
    exit(0);
  printf("%d", main(argc - 1, argv));
}

No imprimirá nada independientemente de los argumentos.

Si está seguro de que nadie lo llamará mainexplícitamente, técnicamente no es una gran diferencia en general, pero mantener un código más claro exitse vería mucho mejor. Si por alguna razón desea llamar main, debe ajustarlo a sus necesidades.

Hablando de C.