Por que uma função sem parâmetros (em comparação com a definição real da função) é compilada?

Acabei de encontrar o código C de alguém que estou confuso sobre o motivo de ele estar compilando. Existem dois pontos que não entendo.

Primeiro, o protótipo da função não possui parâmetros em comparação com a definição real da função. Segundo, o parâmetro na definição da função não tem um tipo.

#include <stdio.h>

int func();

int func(param)
{
    return param;
}

int main()
{
    int bla = func(10);    
    printf("%d", bla);
}

Por que isso funciona? Eu testei em alguns compiladores e funciona bem.

Todas as outras respostas estão corretas, mas apenas para conclusão

Uma função é declarada da seguinte maneira:

  return-type function-name(parameter-list,...) { body... }

tipo de retorno é o tipo de variável que a função retorna. Não pode ser um tipo de matriz ou um tipo de função. Se não for fornecido, então int é assumido .

nome da função é o nome da função.

parameter-list é a lista de parâmetros que a função usa separados por vírgulas. Se nenhum parâmetro for fornecido, a função não aceita nenhum e deve ser definida com um conjunto de parênteses vazio ou com a palavra-chave void. Se nenhum tipo de variável estiver na frente de uma variável na lista de parâmetros, então int é assumido . Matrizes e funções não são passadas para funções, mas são automaticamente convertidas em ponteiros. Se a lista terminar com reticências (, ...), não haverá um número definido de parâmetros. Nota: o cabeçalho stdarg.h pode ser usado para acessar argumentos ao usar reticências.

E novamente por uma questão de completude. Na especificação C11 6: 11: 6 (página: 179)

O uso de declaradores de função com parênteses vazios (não declaradores de tipo de parâmetro no formato de protótipo) é um recurso obsoleto .

Em C func()significa que você pode passar qualquer número de argumentos. Se você não quer argumentos, deve declarar como func(void). O tipo que você está passando para a sua função, se não especificado, é padronizado como int.

int func();é uma declaração de função obsoleta dos dias em que não havia um padrão C, ou seja, os dias da K&R C (antes de 1989, ano em que o primeiro padrão "ANSI C" foi publicado).

Lembre-se de que não havia protótipos no K&R C e a palavra-chave voidainda não foi inventada. Tudo o que você pôde fazer foi informar o compilador sobre o tipo de retorno de uma função. A lista de parâmetros vazia no K&R C significa "um número não especificado, mas fixo" de argumentos. Significa que você deve chamar a função com o fixo mesmo número de argumentos de cada vez (ao contrário de um variádica função como printf, onde o número e tipo pode variar para cada chamada).

Muitos compiladores diagnosticam essa construção; em particular gcc -Wstrict-prototypes, dirá que "a declaração de função não é um protótipo", o que é óbvio, porque parece um protótipo (especialmente se você está envenenado por C ++!), mas não é. É uma declaração de tipo de retorno K&R C de estilo antigo.

Regra geral: nunca deixe uma declaração vazia da lista de parâmetros em branco, use int func(void)para ser específico. Isso transforma a declaração de tipo de retorno K&R em um protótipo C89 adequado. Compiladores estão felizes, desenvolvedores estão felizes, verificadores estáticos estão felizes. Aqueles enganados por ^ W ^ Wfond de C ++ podem se encolher, no entanto, porque precisam digitar caracteres extras quando tentam exercitar suas habilidades em idiomas estrangeiros :-)

• A lista de parâmetros vazia significa "qualquer argumento", portanto a definição não está errada.
• O tipo ausente é assumido como sendo int.

Eu consideraria qualquer compilação que passa isso com falta de nível de aviso / erro configurado, porém, não há sentido em permitir isso para o código real.

É declaração e definição de função no estilo K&R . Do padrão C99 (ISO / IEC 9899: TC3)

Seção 6.7.5.3 Declaradores de função (incluindo protótipos)

Uma lista de identificadores declara apenas os identificadores dos parâmetros da função. Uma lista vazia em um declarador de função que faz parte de uma definição dessa função especifica que a função não possui parâmetros. A lista vazia em um declarador de função que não faz parte de uma definição dessa função especifica que nenhuma informação sobre o número ou tipos de parâmetros é fornecida. (Se os dois tipos de função forem "estilo antigo", os tipos de parâmetro não serão comparados.)

Seção 6.11.6 Declaradores de função

O uso de declaradores de função com parênteses vazios (não declaradores de tipo de parâmetro no formato de protótipo) é um recurso obsoleto.

Seção 6.11.7 Definições de funções

O uso de definições de função com identificadores de parâmetro e listas de declaração separados (não tipo de parâmetro no formato de protótipo e declaradores de identificador) é um recurso obsoleto.

Que o velho estilo significa K & R estilo

Exemplo:

Declaração: int old_style();

Definição:

int old_style(a, b)
    int a; 
    int b;
{
     /* something to do */
}

C assume intse nenhum tipo é fornecido no tipo de retorno da função e na lista de parâmetros . Somente para esta regra é possível seguir coisas estranhas.

Uma definição de função se parece com isso.

int func(int param) { /* body */}

Se é um protótipo que você escreve

int func(int param);

No protótipo, você pode especificar apenas o tipo de parâmetros. O nome dos parâmetros não é obrigatório. assim

int func(int);

Além disso, se você não especificar o tipo de parâmetro, mas o nome intserá assumido como tipo.

int func(param);

Se você for mais longe, o seguinte também funciona.

func();

O compilador assume int func()quando você escreve func(). Mas não coloque func()dentro de um corpo funcional. Isso será uma chamada de função

Conforme afirmado @Krishnabhadra, todas as respostas anteriores de outros usuários têm uma interpretação correta e eu só quero fazer uma análise mais detalhada de alguns pontos.

No Old-C, como no ANSI-C, o " parâmetro formal sem tipo " leva em consideração a dimensão do seu registro de trabalho ou a capacidade de profundidade das instruções (registros de sombra ou ciclo cumulativo de instruções), em uma MPU de 8 bits, será um int16, em 16 bits. MPU e assim será um int16 e assim por diante, no caso de arquiteturas de 64 bits podem optar por compilar opções como: -m32.

Embora pareça uma implementação mais simples em alto nível, para passar vários parâmetros, o trabalho do programador na etapa do tipo de dados de controle de dimensão torna-se mais exigente.

Em outros casos, para algumas arquiteturas de microprocessadores, os compiladores ANSI customizados utilizaram alguns desses recursos antigos para otimizar o uso do código, forçando a localização desses "parâmetros formais não digitados" para trabalhar dentro ou fora do registro de trabalho, hoje você obtém quase o mesmo com o uso de "volátil" e "registrar".

Mas deve-se notar que os compiladores mais modernos não fazem distinção entre os dois tipos de declaração de parâmetros.

Exemplos de uma compilação com o gcc no linux:

 
De qualquer forma, a declaração do protótipo localmente não é útil, porque não há chamada sem parâmetros, a referência a este protótipo será negligente. Se você usar o sistema com "parâmetro formal sem tipo", para uma chamada externa, continue gerando um tipo de dados declarativo de protótipo.

Como isso:

int myfunc(int param);

Com relação ao tipo de parâmetro, já existem respostas corretas aqui, mas se você quiser ouvi-lo do compilador, tente adicionar alguns sinalizadores (os sinalizadores são quase sempre uma boa ideia).

compilando seu programa usando gcc foo.c -Wextraeu recebo:

foo.c: In function ‘func’:
foo.c:5:5: warning: type of ‘param’ defaults to ‘int’ [-Wmissing-parameter-type]

estranhamente -Wextranão pega isso por clang(não reconhece -Wmissing-parameter-typepor algum motivo, talvez pelos históricos mencionados acima), mas -pedanticfaz:

foo.c:5:10: warning: parameter 'param' was not declared, 
defaulting to type 'int' [-pedantic]
int func(param)
         ^
1 warning generated.

E, para a questão do protótipo, como dito novamente acima, int func()refere-se a parâmetros arbitrários, a menos que você o defina de maneira exclusiva, o int func(void)que forneceria os erros conforme o esperado:

foo.c: In function ‘func’:
foo.c:6:1: error: number of arguments doesn’t match prototype
foo.c:3:5: error: prototype declaration
foo.c: In function ‘main’:
foo.c:12:5: error: too many arguments to function ‘func’
foo.c:5:5: note: declared here

ou clangcomo:

foo.c:5:5: error: conflicting types for 'func'
int func(param)
    ^
foo.c:3:5: note: previous declaration is here
int func(void);
    ^
foo.c:12:20: error: too many arguments to function call, expected 0, have 1
    int bla = func(10);
              ~~~~ ^~
foo.c:3:1: note: 'func' declared here
int func(void);
^
2 errors generated.

Se a declaração da função não tiver parâmetros, isto é, vazia, estará recebendo um número não especificado de argumentos. Se você quiser fazê-lo, não use argumentos, altere-o para:

int func(void);

É por isso que normalmente aconselho as pessoas a compilarem seu código:

cc -Wmissing-variable-declarations -Wstrict-variable-declarations -Wold-style-definition

Essas bandeiras reforçam algumas coisas:

• - Declarações de variáveis ​​não permitidas: é impossível declarar uma função não estática sem primeiro obter um protótipo. Isso aumenta a probabilidade de um protótipo em um arquivo de cabeçalho corresponder à definição real. Como alternativa, aplica que você adicione a palavra-chave estática a funções que não precisam estar visíveis publicamente.
• -Wstrict-variable-declarações: O protótipo deve listar corretamente os argumentos.
• -Wold-style-definition: A própria definição de função também deve listar corretamente os argumentos.

Esses sinalizadores também são usados ​​por padrão em muitos projetos de código aberto. Por exemplo, o FreeBSD tem esses sinalizadores ativados ao criar com WARNS = 6 em seu Makefile.