O que é referência para a frente em C?

Question

O que é referência para a frente em C no que diz respeito aos ponteiros?

Posso obter um exemplo?

Answer 1

Veja esta página em referências à frente . Eu não vejo como referência para a frente seria diferente com ponteiros e com outros tipos de vagem.

Note que você pode encaminhar tipos de declaração, e declarar variáveis ??que são ponteiros para esse tipo:

struct MyStruct;
struct MyStruct *ptr;
struct MyStruct var;  // ILLEGAL
ptr->member;  // ILLEGAL

struct MyStruct {
    // ...
};

// Or:

typedef struct MyStruct MyStruct;
MyStruct *ptr;
MyStruct var;  // ILLEGAL
ptr->member;  // ILLEGAL

struct MyStruct {
    // ...
};

Eu acho que isso é o que você está pedindo ao lidar com ponteiros e declaração para a frente.

Answer 2

Eu acho que "referência direta" no que diz respeito aos ponteiros significa algo como isto:

struct MyStruct *ptr; // this is a forward reference.

struct MyStruct
{
  struct MyStruct *next; // another forward reference - this is much more useful
  // some data members
};

O ponteiro é declarado antes que a estrutura aponta para está definida.

O compilador pode ir longe com isso porque as lojas ponteiro um endereço, e você não precisa saber o que é nesse endereço para reservar a memória para o ponteiro.

Answer 3

referência Forward é quando você declarar um tipo, mas não defini-lo.

Ele permite que você use o tipo de ponteiro (ou de referência para C ++), mas você não pode declarar uma variável.

Esta é uma maneira de dizer ao compilador que algo existe

dizer que você tem uma estrutura Plop definida em Plop.h :

struct Plop
{
   int n;
   float f;
};

Agora você quer adicionar algumas funções utilitárias que trabalha com essa estrutura. Você criar outro arquivo PlopUtils.h (Vamos dizer que você não pode mudar Plop.h):

struct Plop; // Instead of including Plop.h, just use a forward declaration to speed up compile time

void doSomething(Plop* plop);
void doNothing(Plop* plop);

Agora, quando você implementar as funções, você terá a definição da estrutura, então você precisa incluir o arquivo Plop.h em sua PlopUtils.cpp :

#include "PlopUtils.h"
#include "Plop.h" // now we need to include the header in order to work with the type

void doSomething(Plop* plop)
{
   plop->n ...
}

void doNothing(Plop* plop);
{
   plop->f ...
}

Answer 4

Eu acho que o compilador C originalmente tinha uma passagem em que ele fez construção da tabela de símbolos e análise semântica juntos. Assim, por exemplo:

    ....
    ... foo(a,b) + 1 ... // assumes foo returns int
    ....

    double foo(double x, double y){ ... } // violates earlier assumption

para evitar isso, você diz:

    double foo(double x, double y); // this is the forward declaration

    ....
    ... foo(a,b) + 1 ... // correct assumptions made
    ....

    double foo(double x, double y){ ... } // this is the real declaration

Pascal teve o mesmo conceito.

Answer 5

Adicionando a respostas anteriores. A situação típica em que se faz referência para a frente é obrigatória é quando um foo estrutura contém um apontador para uma barra de estrutura, e de barras contém um apontador para foo (uma dependência circular entre as declarações). A única maneira de expressar essa situação em C é usar uma declaração para a frente, ou seja:.

struct foo;

struct bar
{
   struct foo *f;
};

struct foo
{
   struct bar *b;
};

Answer 6

referências à frente permitir compilador C para fazer menos passes e reduz significativamente o tempo de compilação. É, provavelmente, era importante há 20 anos quando os computadores foi muito mais lento e compliers menos eficiente.