Por que é necessária a * declaração * de dados e funções na linguagem C, quando a definição é escrita no final do código-fonte?

Considere o seguinte código "C":

#include<stdio.h>
main()
{   
  printf("func:%d",Func_i());   
}

Func_i()
{
  int i=3;
  return i;
}

Func_i()é definido no final do código-fonte e nenhuma declaração é fornecida antes do uso main(). No momento em que o compilador vê Func_i()em main(), ele sai do main()e descobre Func_i(). O compilador, de alguma forma, encontra o valor retornado por Func_i()e o entrega printf(). Eu também sei que o compilador não pode encontrar o tipo de retorno de Func_i(). Por padrão, assume (adivinha?) O tipo de retorno de Func_i()ser int. Ou seja, se o código tivesse float Func_i(), o compilador apresentaria o erro: Tipos conflitantes paraFunc_i() .

A partir da discussão acima, vemos que:

1. O compilador pode encontrar o valor retornado por Func_i().

   • Se o compilador pode encontrar o valor retornado Func_i()saindo do main()e pesquisando o código-fonte, por que não consegue encontrar o tipo de Func_i (), mencionado explicitamente .

2. O compilador deve saber que Func_i()é do tipo float - é por isso que gera o erro de tipos conflitantes.

• Se o compilador sabe que Func_ié do tipo float, então por que ele ainda supõe Func_i()ser do tipo int e gera o erro de tipos conflitantes? Por que não faz com que Func_i()seja do tipo float?

Eu tenho a mesma dúvida com a declaração da variável . Considere o seguinte código "C":

#include<stdio.h>
main()
{
  /* [extern int Data_i;]--omitted the declaration */
  printf("func:%d and Var:%d",Func_i(),Data_i);
}

 Func_i()
{
  int i=3;
  return i;
}
int Data_i=4;

O compilador fornece o erro: 'Data_i' não declarado (primeiro uso nesta função).

• Quando o compilador vê Func_i(), ele desce para o código-fonte para encontrar o valor retornado por Func_ (). Por que o compilador não pode fazer o mesmo para a variável Data_i?

Editar:

Não conheço os detalhes do trabalho interno do compilador, montador, processador etc. A idéia básica da minha pergunta é que, se eu contar (escrever) o valor de retorno da função no código-fonte, finalmente, após o uso dessa função, o idioma "C" permite que o computador encontre esse valor sem dar nenhum erro. Agora, por que o computador não consegue encontrar o tipo da mesma forma. Por que o tipo de Data_i não pode ser encontrado, pois o valor de retorno de Func_i () foi encontrado. Mesmo se eu usar a extern data-type identifier;instrução, não estou dizendo o valor a ser retornado por esse identificador (função / variável). Se o computador consegue encontrar esse valor, por que não consegue encontrar o tipo? Por que precisamos da declaração direta?

Obrigado.

Porque C é uma única passagem , estaticamente digitado , fracamente tipado , compilado linguagem.

1. Passagem única significa que o compilador não olha para a frente para ver a definição de uma função ou variável. Como o compilador não olha para o futuro, a declaração de uma função deve vir antes do uso da função, caso contrário, o compilador não sabe qual é a sua assinatura de tipo. No entanto, a definição da função pode ser posterior no mesmo arquivo ou até mesmo em um arquivo diferente. Veja o ponto 4.

   A única exceção é o artefato histórico que funções e variáveis ​​não declaradas são do tipo "int". A prática moderna é evitar a digitação implícita, sempre declarando funções e variáveis ​​explicitamente.

2. Tipo estaticamente significa que todas as informações de tipo são computadas em tempo de compilação. Essas informações são usadas para gerar código de máquina que é executado em tempo de execução. Não há conceito em C de digitação em tempo de execução. Uma vez que um int, sempre um int, uma vez um float, sempre um float. No entanto, esse fato é um pouco obscurecido pelo próximo ponto.

3. Tipo fraco significa que o compilador C gera automaticamente código para converter entre tipos numéricos sem exigir que o programador especifique explicitamente as operações de conversão. Por causa da digitação estática, a mesma conversão sempre será realizada da mesma maneira sempre no programa. Se um valor flutuante é convertido em um valor int em um determinado ponto no código, um valor flutuante sempre será convertido em um valor int nesse ponto no código. Isso não pode ser alterado no tempo de execução. O valor em si pode mudar de uma execução do programa para a seguinte, é claro, e as instruções condicionais podem alterar quais seções do código são executadas em que ordem, mas uma única seção do código sem chamadas de função ou condicionais sempre executará exatamente o mesmas operações sempre que for executada.

4. Compilado significa que o processo de analisar o código-fonte legível por humanos e transformá-lo em instruções legíveis por máquina é totalmente realizado antes da execução do programa. Quando o compilador está compilando uma função, ele não tem conhecimento do que encontrará mais adiante em um determinado arquivo de origem. No entanto, depois que a compilação (e montagem, vinculação, etc.) for concluída, cada função no executável finalizado conterá ponteiros numéricos para as funções que ele chamará quando for executado. É por isso que main () pode chamar uma função mais abaixo no arquivo de origem. Quando o main () for executado, ele conterá um ponteiro para o endereço de Func_i ().

   O código da máquina é muito, muito específico. O código para adicionar dois números inteiros (3 + 2) é diferente do código para adicionar dois números flutuantes (3.0 + 2.0). Eles são diferentes de adicionar um int a um float (3 + 2.0) e assim por diante. O compilador determina para cada ponto de uma função qual operação exata precisa ser executada nesse ponto e gera código que executa essa operação exata. Feito isso, ele não pode ser alterado sem recompilar a função.

Juntando todos esses conceitos, a razão pela qual main () não pode "ver" mais abaixo para determinar o tipo de Func_i () é que a análise de tipo ocorre no início do processo de compilação. Nesse ponto, apenas a parte do arquivo de origem até a definição de main () foi lida e analisada, e a definição de Func_i () ainda não é conhecida pelo compilador.

O motivo pelo qual main () pode "ver" onde Func_i () deve chamá- lo é que a chamada acontece no tempo de execução, depois que a compilação já resolveu todos os nomes e tipos de todos os identificadores, o assembly já converteu todos os funções ao código da máquina e a vinculação já inseriu o endereço correto de cada função em cada local em que é chamada.

Evidentemente, deixei de fora a maioria dos detalhes sangrentos. O processo real é muito, muito mais complicado. Espero ter fornecido uma visão geral de alto nível o suficiente para responder às suas perguntas.

Além disso, lembre-se de que o que escrevi acima se aplica especificamente a C.

Em outros idiomas, o compilador pode fazer várias passagens pelo código-fonte e, assim, o compilador pode pegar a definição de Func_i () sem que seja pré-declarado.

Em outros idiomas, funções e / ou variáveis ​​podem ser digitadas dinamicamente, para que uma única variável possa reter ou uma única função possa ser passada ou retornada, um número inteiro, um número flutuante, uma sequência, uma matriz ou um objeto em momentos diferentes.

Em outros idiomas, a digitação pode ser mais forte, exigindo que a conversão do ponto flutuante para o número inteiro seja especificada explicitamente. Em outros idiomas, a digitação pode ser mais fraca, permitindo que a conversão da string "3.0" para o float 3.0 no número inteiro 3 seja realizada automaticamente.

E em outros idiomas, o código pode ser interpretado uma linha de cada vez, ou compilado em código de bytes e, em seguida, interpretado, ou compilado na hora certa, ou submetido a uma ampla variedade de outros esquemas de execução.

Uma restrição de design da linguagem C era que ela deveria ser compilada por um compilador de passagem única, o que a torna adequada para sistemas com muita restrição de memória. Portanto, o compilador sabe a qualquer momento apenas sobre as coisas mencionadas anteriormente. O compilador não pode pular adiante na fonte para encontrar uma declaração de função e depois voltar para compilar uma chamada para essa função. Portanto, todos os símbolos devem ser declarados antes de serem utilizados. Você pode pré-declarar uma função como

int Func_i();

na parte superior ou em um arquivo de cabeçalho para ajudar o compilador.

Nos seus exemplos, você usa dois recursos duvidosos da linguagem C que devem ser evitados:

1. Se uma função é usada antes de ser declarada corretamente, é usada como uma "declaração implícita". O compilador usa o contexto imediato para descobrir a assinatura da função. O compilador não varrerá o restante do código para descobrir qual é a declaração real.

2. Se algo for declarado sem um tipo, o tipo será considerado int. É o caso, por exemplo, de variáveis ​​estáticas ou tipos de retorno de função.

Então printf("func:%d",Func_i()), temos uma declaração implícita int Func_i(). Quando o compilador atinge a definição de função Func_i() { ... }, isso é compatível com o tipo Mas se você escreveu float Func_i() { ... }neste momento, você tem a implicação declarada int Func_i()e explicitamente declarada float Func_i(). Como as duas declarações não coincidem, o compilador apresenta um erro.

Limpando alguns equívocos

• O compilador não encontra o valor retornado por Func_i. A ausência de um tipo explícito significa que o tipo de retorno é intpor padrão. Mesmo se você fizer isso:

  Func_i() {
      float f = 42.3;
      return f;
  }

  então o tipo será int Func_i()e o valor de retorno será truncado silenciosamente!

• O compilador finalmente conhece o tipo real de Func_i, mas não conhece o tipo real durante a declaração implícita. Somente quando mais tarde alcança a declaração real, é possível descobrir se o tipo declarado implicitamente estava correto. Mas nesse ponto, o assembly da chamada de função já pode ter sido gravado e não pode ser alterado no modelo de compilação C.

Primeiro, seus programas são válidos para o padrão C90, mas não para os seguintes. int implícito (permitindo declarar uma função sem fornecer seu tipo de retorno) e declaração implícita de funções (permitindo usar uma função sem declará-la) não são mais válidas.

Segundo, isso não funciona como você pensa.

1. O tipo de resultado é opcional no C90, não fornecendo um significa um intresultado. Isso também é válido para a declaração de variáveis ​​(mas você precisa fornecer uma classe de armazenamento staticou extern).

2. O que o compilador faz ao ver a Func_ichamada é sem uma declaração anterior, está assumindo que existe uma declaração

   extern int Func_i();

   ele não procura mais no código para ver com que eficácia Func_ié declarada. Se Func_inão fosse declarado ou definido, o compilador não mudaria seu comportamento ao compilar main. A declaração implícita é apenas para função, não há para variável.

   Observe que a lista de parâmetros vazia na declaração não significa que a função não aceita parâmetros (é necessário especificar (void)isso), significa que o compilador não precisa verificar os tipos dos parâmetros e terá o mesmo conversões implícitas que são aplicadas a argumentos passados ​​para funções variadas.

Você escreveu em um comentário:

A execução é feita linha por linha. A única maneira de encontrar o valor retornado por Func_i () é pular da janela principal

Isso é um equívoco: a execução não é realizada linha por linha. A compilação é feita linha por linha, e a resolução de nomes é feita durante a compilação, e só resolve nomes, não retorna valores.

Um modelo conceitual útil é o seguinte: Quando o compilador lê a linha:

  printf("func:%d",Func_i());

emite código equivalente a:

  1. call "function #2" and put the return value on the stack
  2. put the constant string "func:%d" on the stack
  3. call "function #1"

O compilador também faz uma anotação em alguma tabela interna que ainda function #2é uma função declarada denominada Func_i, que pega um número não especificado de argumentos e retorna um int (o padrão).

Mais tarde, quando ele analisa isso:

 int Func_i() { ...

o compilador Func_iconsulta a tabela mencionada acima e verifica se os parâmetros e o tipo de retorno correspondem. Caso contrário, para com uma mensagem de erro. Se o fizerem, adiciona o endereço atual à tabela de funções internas e segue para a próxima linha.

Portanto, o compilador não "procurou" Func_iquando analisou a primeira referência. Simplesmente anotou em alguma tabela e continuou analisando a próxima linha. E no final do arquivo, ele possui um arquivo de objeto e uma lista de endereços de salto.

Posteriormente, o vinculador pega tudo isso e substitui todos os ponteiros da "função # 2" pelo endereço de salto real, para emitir algo como:

  call 0x0001215 and put the result on the stack
  put constant ... on the stack
  call ...
...
[at offset 0x0001215 in the file, compiled result of Func_i]:
  put 3 on the stack
  return top of the stack

Muito mais tarde, quando o arquivo executável é executado, o endereço de salto já está resolvido e o computador pode simplesmente pular para o endereço 0x1215. Nenhuma pesquisa de nome é necessária.

Isenção de responsabilidade : como eu disse, esse é um modelo conceitual e o mundo real é mais complicado. Compiladores e vinculadores fazem todos os tipos de otimizações malucas hoje. Eles podem até "pular para cima" para procurar Func_i, embora eu duvide. Mas a linguagem C é definida de uma maneira que você pode escrever um compilador super simples como esse. Então, na maioria das vezes, é um modelo muito útil.

C e várias outras linguagens que exigem declarações foram projetadas em uma época em que o tempo e a memória do processador eram caros. O desenvolvimento de C e Unix andou de mãos dadas por algum tempo, e este último não tinha memória virtual até o 3BSD aparecer em 1979. Sem espaço extra para trabalhar, os compiladores tendiam a ser casos de passagem única , porque não tinham. requer a capacidade de manter alguma representação de todo o arquivo na memória de uma só vez.

Compiladores de passagem única são, como nós, sobrecarregados com a incapacidade de ver o futuro. Isso significa que as únicas coisas que eles podem ter certeza são o que disseram explicitamente antes da compilação da linha de código. É claro para qualquer um de nós que Func_i()é declarado posteriormente no arquivo de origem, mas o compilador, que opera em um pequeno pedaço de código de cada vez, não tem idéia de que está chegando.

No início de C (AT&T, K&R, C89), o uso de uma função foo()antes da declaração resultou em uma declaração de fato ou implícita de int foo(). Seu exemplo funciona quando Func_i()é declarado intporque corresponde ao que o compilador declarou em seu nome. Mudá-lo para qualquer outro tipo resultará em conflito porque não corresponde mais ao que o compilador escolheu na ausência de uma declaração explícita. Esse comportamento foi removido no C99, onde o uso de uma função não declarada se tornou um erro.

E os tipos de retorno?

A convenção de chamada para código de objeto na maioria dos ambientes requer conhecer apenas o endereço da função que está sendo chamada, o que é relativamente fácil de lidar com compiladores e vinculadores. A execução pula para o início da função e volta quando ela retorna. Qualquer outra coisa, principalmente arranjos de transmissão de argumentos e um valor de retorno, é determinada inteiramente pelo chamador e chamado em um arranjo chamado de convenção de chamada . Desde que ambos compartilhem o mesmo conjunto de convenções, torna-se possível para um programa chamar funções em outros arquivos de objeto, independentemente de terem sido compilados em qualquer idioma que compartilhe essas convenções. (Na computação científica, você encontra muitas chamadas em C do FORTRAN e vice-versa, e a capacidade de fazer isso vem de ter uma convenção de chamadas.)

Uma outra característica do C inicial era que os protótipos como os conhecemos agora não existiam. Você pode declarar o tipo de retorno de uma função (por exemplo, int foo()), mas não seus argumentos (por exemplo, int foo(int bar)não era uma opção). Isso existia porque, conforme descrito acima, o programa sempre mantinha uma convenção de chamada que poderia ser determinada pelos argumentos. Se você chamou uma função com o tipo errado de argumentos, era uma situação de entrada e saída de lixo.

Como o código do objeto tem a noção de um retorno, mas não um tipo de retorno, um compilador precisa conhecer o tipo de retorno para lidar com o valor retornado. Quando você está executando as instruções da máquina, são apenas bits e o processador não se importa se a memória em que você está tentando comparar um doublerealmente tem um int. Ele apenas faz o que você pede e, se você o quebrar, possui as duas peças.

Considere estes bits de código:

double foo();         double foo();
double x;             int x;
x = foo();            x = foo();

O código à esquerda é compilado em uma chamada para, foo()seguido pela cópia do resultado fornecido pela convenção de chamada / retorno para onde quer que xesteja armazenado. Esse é o caso fácil.

O código à direita mostra uma conversão de tipo e é por isso que os compiladores precisam conhecer o tipo de retorno de uma função. Números de ponto flutuante não podem ser despejados na memória, onde outros códigos esperam ver um intporque não há conversão mágica que ocorre. Se o resultado final precisar ser um número inteiro, é necessário que haja instruções que orientem o processador para fazer a conversão antes do armazenamento. Sem saber o tipo de retorno foo()antecipadamente, o compilador não teria idéia de que o código de conversão é necessário.

Os compiladores de múltiplas passagens permitem todo tipo de coisa, uma das quais é a capacidade de declarar variáveis, funções e métodos após a primeira utilização. Isso significa que quando o compilador começa a compilar o código, ele já viu o futuro e sabe o que fazer. Java, por exemplo, exige múltiplas passagens em virtude do fato de sua sintaxe permitir a declaração após o uso.