¿Qué es una referencia directa en C?

Question

¿Cuál es la referencia directa en C con respecto a los punteros?

¿Puedo obtener un ejemplo?

Answer 1

Consulte esta página en forward references. No veo cómo la referencia directa sería diferente con los punteros y con otros tipos de PoD.

Tenga en cuenta que puede reenviar declarar tipos, y declarar variables que son punteros a ese 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 { 
    // ... 
}; 

Creo que esto es lo que está pidiendo cuando se trata de punteros y declaración adelantada.

Answer 2

creo "referencia hacia adelante" con respecto a los punteros significa algo como esto:

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

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

se declara El puntero antes de que la estructura que apunta se define.

El compilador puede salirse con la suya porque el puntero almacena una dirección, y no necesita saber qué hay en esa dirección para reservar la memoria para el puntero.

Answer 3

La referencia de reenvío es cuando declara un tipo pero no lo define.

Le permite usar el tipo por puntero (o referencia para C++) pero no puede declarar una variable.

Ésta es una forma de decirle al compilador que existe algo

decir que tiene una estructura definida en Plop Plop.h:

struct Plop 
{ 
    int n; 
    float f; 
}; 

ahora quieres añadir algunas funciones de utilidad eso funciona con esa estructura Se crea otro archivo PlopUtils.h (digamos que no se puede cambiar 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); 

Ahora cuando se implementa aquellos función, se necesitará la definición de la estructura, por lo que es necesario incluir el Plop archivo .h en su 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

referencias hacia adelante, deje C compilador para hacer menos pasadas y reduce significativamente el tiempo de compilación. Probablemente fue importante hace unos 20 años cuando las computadoras eran mucho más lentas y las entregas menos eficientes.

Answer 5

Creo que el compilador de C originalmente tenía un pase en el que simulaba el desarrollo de tablas y el análisis semántico. Así, por ejemplo:

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

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

Para evitar esto, es decir:

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 tenían el mismo concepto.

Answer 6

Sumando a las respuestas anteriores.La situación típica en la que la referencia directa es obligatoria es cuando una struct foo contiene un puntero a una barra de estructura, y la barra contiene un puntero a foo (una dependencia circular entre declaraciones). La única manera de expresar esta situación en C es el uso de una declaración hacia adelante, es decir:

struct foo; 

struct bar 
{ 
    struct foo *f; 
}; 

struct foo 
{ 
    struct bar *b; 
};