declaração de retorno vs exit () em main ()

Devo usar exit()ou apenas returndeclarações main()? Pessoalmente, sou a favor das returndeclarações porque sinto que é como ler qualquer outra função e o controle de fluxo quando estou lendo o código é suave (na minha opinião). E mesmo que eu queira refatorar a main()função, ter returnparece ser uma escolha melhor que exit().

Faz exit()algo especial que returnnão faz?

Na verdade, não é uma diferença, mas é sutil. Tem mais implicações para C ++, mas as diferenças são importantes.

Quando eu chamar returnem main(), destruidores serão chamados para os meus objetos escopo localmente. Se eu ligar exit(), nenhum destruidor será chamado para meus objetos com escopo local! Releia isso. exit() não retorna . Isso significa que, assim que eu chamo, não há "backsies". Quaisquer objetos que você criou nessa função não serão destruídos. Frequentemente, isso não tem implicações, mas às vezes ocorre, como o fechamento de arquivos (certamente você deseja que todos os seus dados sejam descarregados para o disco?).

Observe que os staticobjetos serão limpos mesmo se você ligar exit(). Por fim, observe que se você usarabort() , nenhum objeto será destruído. Ou seja, nenhum objeto global, nenhum objeto estático e nenhum objeto local terão seus destruidores chamados.

Prossiga com cuidado ao favorecer a saída em vez do retorno.

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

Outra diferença: exité uma função da Biblioteca Padrão, portanto é necessário incluir cabeçalhos e vincular-se à biblioteca padrão. Para ilustrar (em C ++), este é um programa válido:

int main() { return 0; }

mas para usar, exitvocê precisará incluir:

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

Além disso, isso adiciona uma suposição adicional: a chamada exitde maintem os mesmos efeitos colaterais do retorno zero. Como outros já apontaram, isso depende do tipo de executável que você está construindo (ou seja, quem está chamando main). Você está codificando um aplicativo que usa o C-runtime? Um plugin do Maya? Um serviço do Windows? Um motorista? Cada caso exigirá pesquisa para ver se exité equivalente a return. IMHO usando exitquando você realmente quer dizer return apenas torna o código mais confuso. OTOH, se você realmente quer dizer exit , então, por todos os meios, use-o.

Há pelo menos uma razão para preferir exit: Se qualquer um dos seus atexitmanipuladores referem-se a dados de armazenamento de duração automática no main, ou se você usou setvbufou setbufatribuir a um dos padrões córregos tampão em um de armazenamento de duração automática main, em seguida, retornar de mainproduz comportamento indefinido, mas a chamada exité válida.

Outro uso potencial (geralmente reservado para programas de brinquedo, no entanto) é sair de um programa com invocações recursivas de main.

Eu sempre uso returnporque o protótipo padrão para main()diz que ele retorna um int.

Dito isto, algumas versões dos padrões dão maintratamento especial e assumem que retornará 0 se não houver uma returndeclaração explícita . Dado o seguinte código:

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

O G ++ gera apenas um aviso foo()e ignora o retorno ausente de main:

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

Eu enfaticamente enfatizo o comentário de R. sobre o uso de exit () para evitar a main()recuperação automática do armazenamento antes que o programa realmente termine. Uma return X;declaração in main()não é precisamente equivalente a uma chamada para exit(X);, uma vez que o armazenamento dinâmico de main()desaparece quando main()retorna, mas não desaparece se uma chamada exit()for feita.

Além disso, em C ou em qualquer linguagem semelhante a C, uma returndeclaração sugere fortemente ao leitor que a execução continuará na função de chamada e, embora essa continuação de execução seja tecnicamente verdadeira, se você contar a rotina de inicialização C que chamou sua main()função, não é exatamente o que você quer dizer quando pretende terminar o processo.

Afinal, se você deseja finalizar seu programa a partir de qualquer outra função, exceto que main()você deve chamarexit() . Fazer isso de forma consistente main()também torna seu código muito mais legível e também torna muito mais fácil para alguém re-fatorar seu código; ou seja, o código copiado main()para outra função não se comportará mal por causa de returndeclarações acidentais que deveriam ter sido exit()chamadas.

Portanto, combinando todos esses pontos, a conclusão é que é um mau hábito , pelo menos para C, usar uma returndeclaração para encerrar o programa emmain() .

Exit () faz algo especial que 'return' não faz?

Com alguns compiladores para plataformas incomuns, exit()pode converter seu argumento no valor de saída do seu programa enquanto um retorno demain() apenas pode passar o valor diretamente para o ambiente host sem nenhuma tradução.

O padrão requer um comportamento idêntico nesses casos (especificamente, ele diz que retornar algo que é intcompatível main()deve ser equivalente a chamar exit()com esse valor). O problema é que sistemas operacionais diferentes têm convenções diferentes para interpretar os valores de saída. Em muitos sistemas (MUITOS!), 0 significa sucesso e qualquer outra coisa é um fracasso. Mas, digamos, VMS, valores ímpares significam sucesso e pares significam falha. Se você retornou 0 demain() , um usuário do VMS receberia uma mensagem desagradável sobre uma violação de acesso. Na verdade, não houve uma violação de acesso - essa era simplesmente a mensagem padrão associada ao código de falha 0.

Então o ANSI apareceu e abençoou EXIT_SUCCESSe EXIT_FAILUREcomo argumentos você poderia passar exit(). A norma também diz que exit(0)deve comportar-se de forma idêntica para exit(EXIT_SUCCESS), assim que a maioria das implementações definir EXIT_SUCCESSa 0.

O padrão, portanto, coloca você em um vínculo com o VMS, pois não deixa uma maneira padrão de retornar um código de falha que possua o valor 0.

O compilador VAX / VMS C da era do início dos anos 90, portanto, não interpretou o valor de retorno main(), simplesmente retornou qualquer valor ao ambiente host. Mas se você o utilizasse exit(), faria o que o padrão exigia: converter EXIT_SUCCESS(ou 0) em um código de sucesso e EXIT_FAILUREem um código de falha genérico. Para usar EXIT_SUCCESS, você tinha que passá-lo para exit(), você não poderia devolvê-lo main(). Não sei se versões mais modernas desse compilador preservaram esse comportamento.

Um programa C portátil costumava ficar assim:

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

Além: Se bem me lembro, a convenção VMS para valores de saída é mais diferenciada do que ímpar / par. Na verdade, ele usa algo como os três bits baixos para codificar um nível de gravidade. De um modo geral, no entanto, os níveis ímpares de gravidade indicavam sucesso ou informações diversas e os pares indicavam erros.

Em C, retornar de mainé exatamente o mesmo que chamar exitcom o mesmo valor.

A seção 5.1.2.2.3 da norma C declara:

Se o tipo de retorno da função principal for compatível com int, um retorno da chamada inicial para a função principal será equivalente a chamar a função de saída com o valor retornado pela função principal como argumento ; 11) alcançar o} que finaliza a função principal retorna um valor 0. Se o tipo de retorno não for compatível com int, o status de finalização retornado ao ambiente host não é especificado.

As regras para C ++ são um pouco diferentes, conforme mencionado em outras respostas.

Há realmente uma diferença entre exit(0)e return(0)em main- quando a sua mainfunção é chamada várias vezes.

O seguinte 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á na seguinte saída:

00000

No entanto, este:

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

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

Não imprimirá nada, independentemente dos argumentos.

Se você tem certeza de que ninguém nunca ligará para você mainexplicitamente, não é tecnicamente uma grande diferença em geral, mas manter um código mais claro exitseria muito melhor. Se você, por algum motivo, quiser ligar main- você deve ajustá-lo às suas necessidades.

Falando sobre C.