paulo1205
(usa Ubuntu)
Enviado em 15/02/2016 - 00:37h
Versões antigas (antes de 1999) da linguagem C permitiam declarar e definir funções e variáveis sem especificar seu tipo, assumindo, nesses casos, que o tipo era
int. Como, no entanto, essa assunção de
int implícito era uma grande fonte de erros, o padrão de 1999 passou a adotar o uso sempre explícito do tipo do dado representado ou retornado. Em C++, só as primeiríssimas versões de teste algum dia admitiram
int implícito; mesmo antes do primeiro padrão oficial (1998), C++ já há muito exigia ser explícito sobre tipos.
No caso particular da função
main(), em um programa que execute num computador típico (como nossos PCs), os padrões tanto de C quanto de C++ permitem que ela tenha duas formas, a saber:
CASO 1: Se você não tiver interesse em receber argumentos do ambiente de execução
A forma a se usar em C (também aceita em C++, mas não usual) é a seguinte.
int main(void)
“
Void” significa literalmente “vazio”. Uma lista de argumento que tem somente
void significa, tanto em C como em C++, que a função não aceita receber argumento nenhum.
Entretanto, em C++, em função de polimorfismo, a forma canônica de indicar que uma função não tem argumentos é deixando os parênteses da declaração ou definição vazios, em vez de colocar dentro deles a palavra-chave “
void” -- embora isso seja possível e tecnicamente equivalente, geralmente só é usado quando se quer compatibilidade com C. Por isso, a declaração fica com a forma abaixo.
int main() // Não deve ser usada em C!
Note que essa forma de C++ não deve ser usada em C, pois C, diferentemente de C++, entende uma lista de argumentos completamente vazia com o sentido de que a função pode receber qualquer quantidade de argumentos de quaisquer tipos (semelhante ao efeito de fazer “
int main(...)”).
CASO 2: Se você quiser receber argumentos do ambiente de execução
A forma de
main(), tanto em C quanto em C++, deve ser a seguinte.
int main(int argc, char **argv) // Ou “int main(int argc, char *argv[])”, que é um sinônimo perfeito
Nesse caso,
argc é um contador da quantidade de argumentos usados no momento da invocação do programa (incluindo o próprio nome do programa), e
argv é um vetor de ponteiros para as strings que contêm o texto de cada argumento.
Por convenção,
argv[0] aponta para o nome usado para chamar o programa e
argv[argc] é um ponteiro nulo. Os demais argumentos,
argv[1] até
argv[argc-1], apontam para o texto dos argumentos quem vêm após o nome do programa. Assim sendo, se você tem um programa chamado “
conta_argumentos” e o executar com a seguinte forma
/home/meu_usuario/prog/conta_argumentos Isto "é um" teste.
terá os seguintes valores quando começar a execução da função
main():
argc: 4
argv[0]: "/home/meu_usuario/prog/conta_argumentos"
argv[1]: "Isto"
argv[2]: "é um"
argv[3]: "teste."
argv[4]: NULL (ou nullptr, em C++)
EM AMBOS OS CASOS, NOTE QUE
O tipo de retorno da função
main() é sempre
int. Você deve(*) sempre terminar a função
main() devolvendo um valor inteiro ao ambiente de execução. Essa devolução de valor pode ser feita através de comando
return dentro do corpo de
main() ou de uma chamada à função
exit() em qualquer parte do programa.
Por convenção, um valor inteiro igual a zero significa que o programa executou com sucesso, e qualquer outro valor geralmente é interpretado como sinalização de algum tipo de erro.
-------------
(*) Em C++ e em versões mais recentes do C, o compilador é tolerante com o esquecimento do comando return em main
(), assumindo que se o programa chegou até o final então a execução foi bem-sucedida, e portanto se comporta como se houvesse de fato um comando “return 0;
” no final da função.
Mesmo com esse comportamento sendo especificado pelo padrão, eu aconselho ser sempre explícito com relação ao valor devolvido, principalmente em C. Além de ficar consistente com todas as outras funções que você usar (já que o return implícito só vale para main
()), compiladores mais antigos, mas ainda comumente em uso, não têm a mesma tolerância, e podem (ou pelo menos deveriam) dar erro se não encontrarem um comando explícito de retorno com um valor do tipo adequado.
