O que deve main () retornar em C e C ++?

StackOverflow https://stackoverflow.com/questions/204476

Foi útil?

Solução

O valor de retorno para main deve indicar como o programa saiu. saída normal é geralmente representado por um valor 0 retorno de main. saída anormal geralmente é sinalizado por um retorno diferente de zero, mas não existe um padrão de como diferentes de zero códigos são interpretados. Além disso, como referido por outros, void main() é explicitamente proibido pela C ++ padrão e não deve ser utilizado. C ++ assinaturas main válidos são: 

int main()

e 

int main(int argc, char* argv[])

o que equivale a 

int main(int argc, char** argv)

É importante notar também que em C ++, int main() pode ser deixado sem um retorno declaração, altura em que o padrão é retornar 0. Isto também é verdade com um programa de C99. Se return 0; deve ser omitido ou não está aberto a debate. A gama de assinaturas principais do programa C válido é muito maior.

Além disso, a eficiência não é um problema com a função main. Ela só pode ser inserido e à esquerda uma vez (marcando o início do programa e terminação) de acordo com o padrão C ++. Para C, o caso é diferente e re-entrar main() é permitido, mas deve ser evitado.

Outras dicas

A resposta aceita parece ser direcionados para C ++, então eu pensei que eu iria adicionar uma resposta que se refere a C, e isto difere em algumas maneiras.

ISO / IEC 9899: 1989 (C90):

main() deve ser declarado como qualquer um: 

int main(void)
int main(int argc, char **argv)

ou equivalente. Por exemplo, int main(int argc, char *argv[]) é equivalente para a segunda. Além disso, o tipo int retorno pode ser omitido, pois é um padrão.

Se uma aplicação permitir, main() pode ser declarada de outras maneiras, mas isso faz com que a implementação do programa definido, e não mais rigorosamente em conformidade.

O padrão define 3 valores para retornar que estão rigorosamente em conformidade (isto é, não depende de implementação comportamento definido): 0 e EXIT_SUCCESS para um término bem sucedido, e EXIT_FAILURE para uma rescisão sem sucesso. Quaisquer outros valores não são normalizadas e implementação definido. main() deve ter uma declaração return explícita no fim de evitar um comportamento indefinido.

Finalmente, não há nada errado de uma padrões ponto de vista com a chamada main() a partir de um programa.

ISO / IEC 9899: 1999 (C99):

Para C99, tudo é o mesmo que acima, exceto:

  • O tipo int retorno não pode ser omitido.
  • Você pode omitir a instrução de retorno de main(). Se você faz, e main() terminado, há uma return 0 implícita.

Padrão C - Hospedado Meio Ambiente

Para um ambiente hospedado (que é o normal), o padrão C11 (ISO / IEC 9899: 2011) diz:

5.1.2.2.1 programa de inicialização

A função chamada na inicialização do programa é nomeado main. A implementação não declara protótipo para esta função. Ele deve ser definido com um tipo de retorno de int e sem parâmetros: 

int main(void) { /* ... */ }

ou com dois parâmetros (referido aqui como argc e argv, embora nenhum nome pode ser utilizado, uma vez que são locais para a função na qual eles são declarados): 

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

ou equivalente;. 10) ou em algum outro modo definido pela implementação

Se eles forem declarados, os parâmetros para a função principal deve obedecer à seguinte restrições:

  • O valor da argc deve ser não negativo.
  • argv[argc] deve ser um ponteiro nulo.
  • Se o valor da argc é maior do que zero, os membros da matriz argv[0] através argv[argc-1] inclusiva devem conter ponteiros para strings, que são dadas valores por meio de acolhimento antes da inicialização do programa definido pela implementação. o a intenção é fornecer a informação programa determinada antes da inicialização do programa de outras partes do ambiente hospedado. Se o ambiente de acolhimento não é capaz de fornecendo cordas com letras em ambos os maiúsculas e minúsculas, a implementação devem assegurar que as cordas são recebidos em letras minúsculas.
  • Se o valor da argc é maior do que zero, a string apontada por argv[0] representa o nome do programa; argv[0][0] será o caractere nulo se o nome do programa não está disponível a partir do ambiente de host. Se o valor da argc é maior do que um, as cordas apontada por argv[1] através argv[argc-1] representam os parâmetros do programa.
  • Os parâmetros argc e argv e as cordas apontado pela matriz argv deve ser modificáveis ??pelo programa, e mantêm seus valores última armazenados entre o programa inicialização e encerramento do programa.

10) Assim, int pode ser substituído por um nome typedef definido como int, ou do tipo de argv pode ser escrito como char **argv, e assim por diante.

rescisão Programa em C99 ou C11

O valor retornado de main() é transmitido para o 'ambiente' de uma forma definida pela implementação.

5.1.2.2.3 rescisão Programa

1 Se o tipo de retorno da função main é um tipo compatível com int, um retorno do chamada inicial para a função main é equivalente a chamar a função exit com o valor retornado pela função main como argumento; 11) atingindo o } que termina o função main retorna um valor de 0. Se o tipo de retorno não é compatível com int, o status de terminação voltou para o ambiente de acolhimento não é especificado.

11) De acordo com 6.2.4, a vida útil dos objetos com duração de armazenamento automático declarou em main terá terminado no primeiro caso, mesmo quando eles não têm neste último.

Note que 0 é obrigatória como 'sucesso'. Você pode usar EXIT_FAILURE e EXIT_SUCCESS de <stdlib.h> se você preferir, mas 0 é bem estabelecida, e assim é 1. Veja também códigos de saída maiores que 255 -?. possíveis

Em C89 (umd daí em Microsoft C), não há nenhuma declaração sobre o que acontece se a função main() retornos, mas não especifica um valor de retorno; -lo, portanto, leva a um comportamento indefinido.

7.22.4.4 A função exit

¶5 Finalmente, o controle é devolvido ao meio ambiente host. Se o valor da status é zero ou EXIT_SUCCESS, uma forma do estatuto definido pela implementação término bem-sucedido é retornado. Se o valor da status é EXIT_FAILURE, uma forma do estatuto definido pela implementação rescisão sem sucesso é retornado. Caso contrário, o status retornado é definido pela implementação.

padrão C ++ - Hospedado Meio Ambiente

A C ++ 11 padrão (ISO / IEC 14882: 2011) diz:

3.6.1 Função principal [basic.start.main]

¶1 Um programa deve conter uma função global chamada principal, que é o início designada do programa. [...]

¶2 Uma implementação não deve predefinir a função principal. Esta função não deve ser sobrecarregado. Deve tem um tipo de retorno do tipo int, mas caso contrário seu tipo é definido pela implementação. todas as implementações deve permitir que ambas as seguintes definições de principal: 

int main() { /* ... */ }

e 

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

Neste último argc formulário deve ser o número de argumentos passados ??para o programa a partir do ambiente em que o programa é executado. Se argc é diferente de zero esses argumentos devem ser fornecidas em argv[0] através argv[argc-1] como ponteiros para os caracteres iniciais de cordas de vários bytes de terminação nula (NTMBSs) (17.5.2.1.4.2) e argv[0] deve ser o ponteiro para o carácter inicial de uma NTMBS que representa o nome usado para invocar o programa ou "". O valor da argc deve ser não-negativo. O valor da argv[argc] deve ser 0. [Nota: Recomenda-se que quaisquer outras (opcional) parâmetros ser adicionado após argv. -fim Nota]

¶3 A função main não devem ser utilizados dentro de um programa. A articulação (3.5) de main é definido pela implementação. [...]

¶5 A instrução de retorno na principal tem o efeito de deixar a função principal (destruir quaisquer objetos com automático duração de armazenamento) e std::exit chamando com o valor de retorno como o argumento. Se o controlo atinge a extremidade de principal sem encontrar uma instrução de retorno, o efeito é o de execução 

return 0;

O padrão C ++ explicitamente diz que "[a função principal] deve ter um tipo de retorno do tipo int, mas caso contrário seu tipo é definido pela implementação", e exige as mesmas duas assinaturas como o padrão C para serem suportados como opções. Assim, um 'void main ()' directamente não é permitido pelo padrão C ++, embora não há nada que possa fazer para impedir a implementação não-padrão permitindo alternativas. Note-se que proíbe C ++ o usuário chamando main (mas o padrão C não).

Há um parágrafo do §18.5 Iniciar e terminação no C ++ 11 padrão que é idêntico ao parágrafo de §7.22.4.4 A função exit no C11 padrão (citado acima), para além de uma nota de rodapé (que simplesmente documentos que EXIT_SUCCESS e EXIT_FAILURE são definidos em <cstdlib>).

Padrão C - Comum Extensão

Classicamente, sistemas Unix apoiar uma terceira variante: 

int main(int argc, char **argv, char **envp) { ... }

O terceiro argumento é uma lista terminada em null de ponteiros para strings, cada uma das quais é uma variável de ambiente que tem um nome, um sinal de igual e um valor (possivelmente vazio). Se você não usar isso, você ainda pode obter no ambiente via 'extern char **environ;'. Por um longo tempo, que não have um cabeçalho que declarou, mas o padrão POSIX 2008 agora exige que seja declarada em <unistd.h>.

Isto é reconhecido pelo padrão C como uma extensão comum, documentado no Anexo J:

argumentos J.5.1 Ambiente

¶1 Em um ambiente hospedado, a função principal recebe um terceiro argumento, char *envp[], que aponta para uma matriz terminada com nulo de ponteiros para char, cada uma das quais aponta para uma cadeia que fornece informações sobre o ambiente para esta execução do programa (5.1.2.2.1).

Microsoft C

O Microsoft VS 2010 compilador é interessante. O site diz:

A sintaxe declaração para principal é 

 int main();

ou, opcionalmente, 

int main(int argc, char *argv[], char *envp[]);

Como alternativa, as funções main e wmain pode ser declarada como retornando void (sem valor de retorno). Se você declarar main ou wmain como retornando vazio, você não pode retornar um código de saída para o processo pai ou sistema operacional usando uma instrução de retorno. Para retornar um código de saída quando main ou wmain é declarado como void, você deve usar a função exit.

Não é claro para mim o que acontece (o código de saída é devolvido ao pai ou OS) quando um programa com void main() faz exit -. Ea MS web site é silencioso demasiado

Curiosamente, MS não prescreve a versão com dois argumentos de main() que os padrões do C e C ++ requerem. Ele só prescreve uma forma de três argumento que o terceiro argumento é char **envp, um ponteiro para uma lista de variáveis ??de ambiente.

A página Microsoft também lista algumas outras alternativas -. wmain() que leva cadeias de caracteres de largura e pouco mais

A Microsoft Visual versão de desta página não lista void main() como uma alternativa. As versões da Microsoft Visual Studio 2008 avante fazer.

Padrão C - independente Meio Ambiente

Como observado no início, os requisitos acima se aplica a ambientes hospedados. Se você está trabalhando com um ambiente independente (que é a alternativa para um ambiente hospedado), então o padrão tem muito menos a dizer. Para um ambiente independente, a função chamada na necessidade inicialização do programa não ser chamado main e não há restrições sobre seu tipo de retorno. A norma diz:

5.1.2 ambientes de execução

ambientes de execução Dois são definidos: autônoma e organizada. Em ambos os casos, inicialização do programa ocorre quando uma função C designado é chamado pela execução meio Ambiente. Todos os objetos com duração de armazenagem estática deve ser inicializado (conjunto aos seus valores iniciais) antes de inicialização do programa. O modo e o tempo de tal inicialização são de outro modo não especificado. terminação programa retorna o controle para o ambiente de execução.

5.1.2.1 ambiente Independente

Em um ambiente autônomo (em que a execução do programa C pode ocorrer sem qualquer benefício de um sistema operacional), o nome eo tipo da função chamada na inicialização do programa são definidos pela implementação. Quaisquer instalações da biblioteca disponíveis a um progra autônomom, diferente do conjunto mínimo exigido pela cláusula 4, são definidas pelo implementação.

O efeito do término do programa em um ambiente independente é definido pela implementação.

A referência cruzada com a cláusula 4 Conformidade refere-se a este:

¶5 A conformar estritamente programa deve usar apenas os recursos da linguagem e biblioteca especificada nesta Norma Internacional. 3) Não deve produzir uma saída dependente de qualquer não especificada , indefinido, ou o comportamento implementação-definido, e não deve exceder qualquer limite mínimo implementação.

¶6 As duas formas de conformidade implementação são hospedado e independente . A conformando implementação hospedada deve aceitar qualquer programa rigorosamente em conformidade. A em conformidade independente implementação deve aceitar qualquer programa rigorosamente de acordo em que o uso das características especificadas na cláusula biblioteca (cláusula 7) se limita ao conteúdo do padrão cabeçalhos <float.h>, <iso646.h>, <limits.h>, <stdalign.h>, <stdarg.h>, <stdbool.h>, <stddef.h>, <stdint.h>, e <stdnoreturn.h>. Uma implementação conforme pode ter extensões (incluindo adicional funções de biblioteca), desde que não altere o comportamento de qualquer programa rigorosamente em conformidade. 4)

¶7 A conformando programa é aquele que é aceitável para uma implementação em conformidade. 5)

3) A rigorosamente de acordo programa pode usar recursos condicionais (ver 6.10.8.3), desde que o uso é guardada por uma directiva de pré-processamento inclusão condicional apropriado usando a macro relacionado. Por exemplo: 

#ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
    /* ... */
    fesetround(FE_UPWARD);
    /* ... */
#endif

4) Isto implica que uma conformidade reservas de implementação há identificadores diferentes daqueles explicitamente reservadas nesta Norma.

5) rigorosamente de acordo programas se destinam a ser maximamente portátil entre conforme implementações. programas de conformidade pode depender de recursos não-portáteis de uma implementação em conformidade.

É notável que a única cabeçalho exigido de um ambiente independente que realmente define quaisquer funções é <stdarg.h> (e mesmo aqueles podem ser - e são frequentemente - apenas macros).

padrão C ++ - independente Meio Ambiente

Assim como o padrão C reconhece tanto o ambiente hospedado e autônomo, o mesmo acontece com o padrão C ++. (Citações de ISO / IEC 14882:. 2011)

o cumprimento 1.4 Implementação [intro.compliance]

¶7 dois tipos de implementações são definidas: a implementação hospedada e autônomo implementação . Para uma implementação hospedada, esta Norma define o conjunto de bibliotecas disponíveis. Um autônomo implementação é aquele em que a execução pode ter lugar sem o benefício de um sistema operacional, e tem um conjunto definido pela implementação de bibliotecas que inclui algumas bibliotecas de suporte ao idioma (17.6.1.3).

¶8 Uma implementação conforme pode ter extensões (incluindo funções de biblioteca adicionais), desde que não altere o comportamento de qualquer programa bem-formado. Implementações são necessárias para diagnosticar programas que usar essas extensões que são mal-formados de acordo com esta Norma. Tendo feito isso, no entanto, eles podem compilar e executar tais programas.

¶ 9 Cada aplicação deve incluir documentação que identifica todas as construções que não suportam condicionalmente-suportado e define todas as características específicas da localidade. 3

3) Essa documentação também define o comportamento definido pela implementação; ver 1.9.

17.6.1.3 Independente implementações [o cumprimento]

Dois tipos de implementações são definidas: hosted e independente (1,4). Para uma implementação hospedada, esta Norma descreve o conjunto de cabeçalhos disponíveis.

A implementação independente tem um conjunto de cabeçalhos definido pela implementação. Este conjunto deve incluir, pelo menos, os cabeçalhos mostrados na Tabela 16.

a versão fornecida do <cstdlib> cabeçalho declarará, pelo menos, as funções abort, atexit, at_quick_exit, exit, e quick_exit (18,5). Os outros cabeçalhos listados nesta tabela devem cumprir os mesmos requisitos que para uma implementação hospedada.

Tabela 16 - cabeçalhos C ++ para autoportante implementações 

Subclause                           Header(s)
                                    <ciso646>
18.2  Types                         <cstddef>
18.3  Implementation properties     <cfloat> <limits> <climits>
18.4  Integer types                 <cstdint>
18.5  Start and termination         <cstdlib>
18.6  Dynamic memory management     <new>
18.7  Type identification           <typeinfo>
18.8  Exception handling            <exception>
18.9  Initializer lists             <initializer_list>
18.10 Other runtime support         <cstdalign> <cstdarg> <cstdbool>
20.9  Type traits                   <type_traits>
29    Atomics                       <atomic>

Que tal usar int main() em C?

O §5.1.2.2.1 padrão das C11 mostra a notação padrão preferido - int main(void) - mas há também dois exemplos no padrão que mostram int main(): §6.5.3.4 ¶8 e §6.7.6.3 ¶20 . Agora, é importante notar que os exemplos não são 'normativo'; eles são apenas ilustrativos. Se houver erros nos exemplos, eles não afetam diretamente o texto principal da norma. Dito isto, eles são fortemente indicativo de comportamento esperado, por isso, se o padrão inclui int main() em um exemplo, ele sugere que int main() não é proibido, mesmo que não é a notação preferido.

6.5.3.4 Os operadores sizeof e _Alignof

...

¶8 EXEMPLO 3 Neste exemplo, o tamanho de uma matriz de comprimento variável é computadorizada e devolvido a partir de uma função de: 

#include <stddef.h>

size_t fsize3(int n)
{
    char b[n+3]; // variable length array
    return sizeof b; // execution time sizeof
}
int main()
{
    size_t size;
    size = fsize3(10); // fsize3 returns 13
    return 0;
}

Eu acredito que main() deve retornar tanto EXIT_SUCCESS ou EXIT_FAILURE. Eles são definidos no stdlib.h

Note que os padrões do C e C ++ definir dois tipos de implementações:. Autônoma e organizada

  • C90 ambiente hospedado

    formas permitidos 1 : 

    int main (void)
int main (int argc, char *argv[])

main (void)
main (int argc, char *argv[])
/*... etc, similar forms with implicit int */

    Comentários:

    Os dois primeiros são explicitamente declarado como as formas admitidas, os outros estão implicitamente permitida porque C90 permitido "int implícita" para o tipo de retorno e os parâmetros de função. é permitida nenhuma outra forma.

  • C90 ambiente autônomo

    Qualquer forma ou nome principal é permitido 2 .

  • C99 ambiente hospedado

    formas permitidos 3 : 

    int main (void)
int main (int argc, char *argv[])
/* or in some other implementation-defined manner. */

    Comentários:

    C99 removido "int implícita" para main() não é mais válido.

    Um estranho, frase ambígua "ou de alguma outra maneira definido pela implementação" foi introduzido. Isto pode ser interpretado como "os parâmetros para int main() pode variar" ou como "principal pode ter qualquer forma definida pela implementação".

    Alguns compiladores ter escolhido para interpretar o padrão neste último caminho. Indiscutivelmente, não se pode facilmente estado que eles não estão rigorosamente de acordo citando o padrão em si mesmo, uma vez que está é ambíguo.

    No entanto, para permitir formas completamente selvagens de main() foi provavelmente (?) Não a intenção desta nova sentença. A lógica C99 (não normativo) implica que a sentença se refere a parâmetros adicionais para int main 4 .

    No entanto, a seção de encerramento do programa ambiente hospedado, em seguida, continua discutindo sobre o caso em que principal não retorna int 5 . Embora essa seção não é normativa para como principal deve ser declarado, ele definitivamente implica que o principal pode ser declarado de uma forma completamente definido pela implementação mesmo em sistemas hospedados.

  • C99 ambiente autônomo

    Qualquer forma ou nome principal é permitido 6 .

  • C11 ambiente hospedado

    formas permitidos 7 : 

    int main (void)
int main (int argc, char *argv[])
/* or in some other implementation-defined manner. */

  • C11 ambiente autônomo

    Qualquer forma ou nome principal é permitido 8 .

Note que int main() não foi listado como uma forma válida para qualquer aplicação hospedada do C em qualquer uma das versões acima. Em C, ao contrário do C ++, () e (void) têm significados diferentes. O primeiro é uma característica obsolescente que pode ser removido a partir da língua. Veja as instruções de linguagem futuro C11:

6.11.6 declarators Função

O uso de declarators função com parênteses vazios (não protótipo de formato tipo de parâmetro declarators) é uma característica obsoleta.

  • C ++ 03 ambiente hospedado

    formas permitidos 9 : 

    int main ()
int main (int argc, char *argv[])

    Comentários:

    Observe o parêntese vazia na primeira forma. C ++ e C são diferentes neste caso, porque em C ++ Isto significa que a função não tem parâmetros. Mas em C isso significa que ele pode tomar qualquer parâmetro.

  • C ++ 03 ambiente autônomo

    O nome da função chamada na inicialização é definido pela implementação. Se for chamado main() deve seguir as formas declaradas 10 : 

    // implementation-defined name, or 
int main ()
int main (int argc, char *argv[])

  • C ++ 11 ambiente hospedado

    formas permitidos 11 : 

    int main ()
int main (int argc, char *argv[])

    Comentários:

    O texto da norma foi alterada, mas tem o mesmo significado.

  • C ++ 11 ambiente autônomo

    O nome da função chamada na inicialização é definido pela implementação. Se for chamado main() deve seguir as formas declaradas 12 : 

    // implementation-defined name, or 
int main ()
int main (int argc, char *argv[])

Referências

  1. ANSI X3.159-1989 2.1.2.2 ambiente hospedado. "Program arranque "

    A função chamada na inicialização do programa é nomeado principal. o implementação declara nenhum protótipo para esta função. Será definido com um tipo de retorno de int e sem parâmetros: 

    int main(void) { /* ... */ }

    ou com dois parâmetros (referido aqui como argc e argv, embora possa ser utilizada qualquer nomes, como eles são locais para a função na qual eles são declarados): 

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

  2. ANSI X3.159-1989 2.1.2.1 ambiente Independente:

    Em um ambiente autônomo (em que a execução do programa C pode demorar lugar sem qualquer benefício de um sistema operacional), o nome eo tipo da função chamada na inicialização do programa são definidos pela implementação.

  3. ISO 9899: 1999 5.1.2.2 ambiente Hosted -> 5.1.2.2.1 programa de inicialização

    A função chamada na inicialização do programa é nomeado principal. o implementação declara nenhum protótipo para esta função. Será definido com um tipo de retorno de int e sem parâmetros: 

    int main(void) { /* ... */ }

    ou com dois parâmetros (referido aqui como argc e argv, embora possa ser utilizada qualquer nomes, como eles são locais para a função na qual eles são declarados): 

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

    ou equivalente; 9) ou em algum outro implementação definida maneira.

  4. Justificativa para Norma Internacional - Linguagens de Programação - C, Revisão 5.10. 5.1.2.2 ambiente Hosted -> 5.1.2.2.1 programa de inicialização

    O comportamento dos argumentos para principal, e da interação de saída, principal e atexit (Veja §7.20.4.2) foi codificado para conter alguma variedade indesejado na representação de argv cordas, e no significado dos valores retornado por principal.

    A especificação de argc e argv como argumentos para principal reconhece extensa prática anterior. argv [argc] é necessário para ser um ponteiro nulo para fornecer uma verificação redundante para o fim da lista, também com base na prática comum.

    principal é a única função que pode portably ser declarados com zero ou dois argumentos. (O número de argumentos de outras funções deve corresponder exatamente entre invocação e definição.) Este caso especial simplesmente reconhece a prática generalizada de deixar fora os argumentos para principal quando o programa não acessar as strings argumentos programa. Enquanto muitas implementações apoiar mais de dois argumentos para principal tal prática, não é nem abençoado nem proibido pela norma; um programa que define principais com três argumentos não está rigorosamente de acordo (ver §J.5.1.).

  5. ISO 9899: 1999 5.1.2.2 ambiente Hosted -> 5.1.2.2.3 rescisão Programa

    Se o tipo de retorno da função principal é um tipo compatível com int, um retorno da chamada inicial para a função principal é equivalente a chamar a função de saída com o valor retornado pela função principal como seu argumento; 11), atingindo o } que termina a função principal retorna um valor de 0. Se o tipo de retorno não é compatível com int, o status de terminação voltou para o ambiente de acolhimento não é especificado.

  6. ISO 9899: 1999 5.1.2.1 ambiente Independente

    Em um ambiente autônomo (em que a execução do programa C pode ocorrer sem qualquer benefício de um sistema operacional), o nome eo tipo da função chamada na inicialização do programa são a implementação definida.

  7. ISO 9899: 2011 5.1.2.2 ambiente Hosted -> 5.1.2.2.1 programa de inicialização

    Esta seção é idêntico ao C99 citado acima.

  8. ISO 9899: 1999 5.1.2.1 ambiente Independente

    Esta seção é idêntico ao C99 citado acima.

  9. ISO 14882: 2003 3.6.1 Função principal

    Uma implementação não deve predefinir a função principal. Esta função não deve ser sobrecarregado. Ele deve ter um tipo de retorno do tipo int, mas caso contrário seu tipo é definido pela implementação. Todas as implementações devem permitir que ambas as seguintes definições de principal: 

    int main() { /* ... */ }

    e 

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

  10. ISO 14882: 2003 3.6.1 Função principal

    É a implementação-definido se um programa em um ambiente independente é necessária para definir uma função principal.

  11. ISO 14882: 2011 3.6.1 Função principal

    Uma implementação não deve predefinir a função principal. Esta função não deve ser sobrecarregado. Ele deve ter um tipo de retorno do tipo int, mas caso contrário seu tipo é definido pela implementação. Todas as implementações devem permitir que tanto

    - uma função de () retornando int e

    - uma função de (int, ponteiro de ponteiro de carvão animal) retornando int

    como o tipo de principal (8.3.5).

  12. ISO 14882: 2011 3.6.1 Função principal

    Esta seção é idêntica à C ++ 03 um citados acima.

Voltar 0 em caso de sucesso e não-zero para erro. Este é o padrão usado pelo UNIX e DOS scripting para descobrir o que aconteceu com o seu programa.

main() em C89 e K & R C tipos de retorno não especificado padrão para ‘int`. 

return 1? return 0?

  1. Se você não escrever uma instrução de retorno no int main(), o { fechamento retornará 0 por padrão.

  2. return 0 ou return 1 será recebido pelo processo pai. Em uma casca de ele entra em uma variável de shell, e se você estiver executando o seu formulário de programa de uma concha e não usando essa variável, então você não precisa se preocupar com o valor de retorno de main().

Consulte Como posso conseguir o meu principal função voltou? . 

$ ./a.out
$ echo $?

Desta forma, você pode ver que é a variável $? que recebe o byte menos significativo do valor de retorno de main().

Em Unix e scripts DOS, return 0 em caso de sucesso e diferente de zero para erros geralmente são devolvidos. Este é o padrão usado por Unix e DOS scripting para descobrir o que aconteceu com o seu programa e controlar todo o fluxo.

Tenha em mente que, mesmo que você está retornando um int, alguns sistemas operacionais (Windows) truncar o valor devolvido a um único byte (0-255).

O valor de retorno pode ser usado pelo sistema operacional para verificar como o programa foi fechado.

Voltar valor 0 significa geralmente OK na maioria dos sistemas operacionais (os que eu posso pensar de qualquer maneira).

Ele também pode ser verificado quando você chamar um processo de si mesmo, e ver se o programa saiu e terminou corretamente.

de não apenas uma convenção de programação.

O valor de retorno de shows main() como o programa saiu. Se o valor de retorno é zero isso significa que a execução foi bem sucedida enquanto qualquer valor diferente de zero irá representar que algo correu mal na execução.

Eu estava sob a impressão de que especifica padrão que principal não precisa de um valor de retorno como um retorno bem sucedido baseou OS (zero em um poderia ser um sucesso ou um fracasso em outro), portanto, a ausência de retorno foi um sugestão para o compilador para inserir o próprio retorno bem sucedido.

No entanto, eu normalmente retornar 0.

Retornando 0 deve dizer ao programador que o programa foi concluído com êxito o trabalho.

Omitir return 0

Quando um programa C ou C ++ chega ao fim da main o compilador irá gerar automaticamente o código para retornar 0, por isso não há necessidade de colocar return 0; explicitamente no final do main.

Nota: quando faço esta sugestão, é quase invariavelmente seguido por um dos dois tipos de comentários: "Eu não sabia que" ou "Isso é um mau conselho!" Meu raciocínio é que ele é seguro e útil para dependem do comportamento do compilador explicitamente apoiada pela norma. Para C, uma vez que C99; ver ISO / IEC 9899: 1999 secção 5.1.2.2.3:

[...] um retorno da chamada inicial para a função main é equivalente a chamar a função exit com o valor retornado pela função main como argumento; atingindo o } que termina a função main retorna um valor de 0.

for C ++, uma vez que o primeiro padrão em 1998; ver ISO / IEC 14882: 1998 seção 3.6.1:

Se o controle chega ao fim da principal sem encontrar uma instrução de retorno, o efeito é o de executar return 0;

Todas as versões de ambos os padrões, desde então (C99 e C ++ 98) mantiveram a mesma idéia. Contamos com funções membro geradas automaticamente em C ++, e algumas pessoas escrevem declarações return; explícitas no final de uma função void. Razões contra a omissão parece resumir-se a " parece estranho ". Se, como eu, você está curioso sobre a razão para a mudança para o padrão C ler esta pergunta . Observe também que no início de 1990 este foi considerado "prática descuidada" porque era um comportamento indefinido (embora amplamente suportado) no momento.

Além disso, o orientações núcleo ++ C contém múltiplas instâncias de omitir return 0; no final do main e há casos em que um retorno explícito é escrito. Embora ainda não há uma orientação específica sobre este tema específico nesse documento, que parece, pelo menos uma aprovação tácita da prática.

Então eu defensor omiti-lo; outros discordam (muitas vezes com veemência!) Em qualquer caso, se você encontrar o código que omite-lo, você vai saber que ele é explicitamente apoiado pelo padrão e você sabe o que significa.

O que o retorno depende do que você quer fazer com o executável. Por exemplo, se você estiver usando o seu programa com um shell de linha de comando, então você precisa retornar 0 para um sucesso e um diferente de zero para o fracasso. Então você seria capaz de usar o programa em conchas com o processamento condicional, dependendo do resultado do seu código. Além disso, você pode atribuir qualquer valor diferente de zero como por sua interpretação, por exemplo, para erros críticos diferentes pontos de saída programa poderia terminar um programa com diferentes valores de saída, e que está disponível para o shell chamando que pode decidir o que fazer inspecionando o valor retornado. Se o código não se destina ao uso com conchas e o valor retornado não incomodar ninguém, então ele pode ser omitido. Eu pessoalmente uso o int main (void) { .. return 0; .. } assinatura

Se você realmente tem questões relacionadas com a eficiência de retornar um número inteiro de um processo, você provavelmente deve evitar chamar esse processo tantas vezes que esse valor de retorno se torna um problema.

Se você está fazendo isso (chamar um processo tantas vezes), você deve encontrar uma maneira de colocar a sua lógica diretamente dentro do chamador, ou em um arquivo DLL, sem alocar um processo específico para cada chamada; as múltiplas atribuições processo trazê-lo o problema de eficiência relevante neste caso.

Em detalhe, se você só quer saber se o retorno 0 é mais ou menos eficiente do que retornar 1, pode depender do compilador, em alguns casos, mas genericamente, assumindo que eles são lidos a partir da mesma fonte (local, campo, constante, embutido no código, resultado da função, etc.) que exige exatamente o mesmo número de ciclos de relógio.

O que é a maneira correta (mais eficiente) para definir a função main () em C e C ++ - int main () ou void main () -? E porque

As palavras "(mais eficiente)" não mudam a questão. A menos que você está em um ambiente autônomo, há uma maneira universalmente correta para main() declarar, e isso é como retornar int.

O que deve main() retorno em C e C ++?

Não é o que deve retorno main(), é o que faz main() retorno. main() é, naturalmente, uma função que alguém chama outra pessoa. Você não tem nenhum controle sobre o código que chama main(). Portanto, você deve declarar main() com uma assinatura tipo correto de acordo com o seu interlocutor. Você simplesmente não têm qualquer escolha na matéria. Você não tem que se perguntar o que é mais ou menos eficiente, ou o que é melhor ou pior estilo, ou qualquer coisa assim, porque a resposta já está perfeitamente bem definido, para você, pela C e + padrões C. Apenas segui-los.

Se int main (), em seguida, retornar 1 ou retornar 0?

0 para o sucesso, diferente de zero para o fracasso. Novamente, não é algo que você precisa (ou para) escolher: é definido pela interface você deveria ser em conformidade com

.

Aqui está uma pequena demonstração do uso de códigos de retorno ...

Ao utilizar as várias ferramentas que o terminal Linux fornece um pode usar o código de retorno por exemplo, para o tratamento de erros após o processo foi concluído. Imagine que o seguinte myfile arquivo de texto está presente:

Este é um exemplo a fim de verificar como funciona o grep.

Quando você executar o comando grep um processo é criado. Uma vez que é através (e não quebrar) ele retorna algum código entre 0 e 255. Por exemplo: 

$ grep order myfile

Se você fizer 

$ echo $?
$ 0

Você receberá um 0. Por quê? Porque grep encontrado um fósforo e retornou um código de saída 0, que é o valor habitual para sair com um sucesso. Vamos verificar-lo novamente, mas com algo que não está dentro do nosso arquivo de texto e, portanto, nenhuma correspondência será encontrada: 

$ grep foo myfile
$ echo $?
$ 1

Desde grep não conseguiu igualar o "foo" token com o conteúdo do nosso arquivo o código de retorno é de 1 (este é o caso usual quando ocorre uma falha, mas como dito acima você tem a abundância de valores para escolher).

Agora o seguinte script bash (simplesmente digitá-lo em um terminal Linux), embora muito básico deve dar uma ideia da manipulação de erro: 

$ grep foo myfile
$ CHECK=$?
$ [ $CHECK -eq 0] && echo 'Match found'
$ [ $CHECK -ne 0] && echo 'No match was found'
$ No match was found

Depois da segunda linha nada é impresso ao terminal uma vez que "foo" feita retorno grep 1 e verificar se o código de retorno de grep foi igual a 0. A segunda ecos instrução condicional a sua mensagem na última linha, uma vez que é verdade devido ao check-== 1.

Como você pode ver se você está chamando isso e esse processo às vezes é essencial para ver o que ele está de volta (pelo valor de retorno de main ()).

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top