¿Qué es la referencia directa en C?

Question

¿Qué es la referencia directa en C con respecto a los punteros?

¿Puedo obtener un ejemplo?

Answer 1

Consulte esta página en referencias directas . No veo cómo las referencias directas serían diferentes con 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 de avance.

Answer 2

Creo que "referencia directa" 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
};

El puntero se declara antes de definir la estructura a la que apunta.

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 directa 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.

Esta es una manera de decirle al compilador que algo existe

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

struct Plop
{
   int n;
   float f;
};

Ahora desea agregar algunas funciones de utilidad que funcionen con esa estructura. Crea otro archivo PlopUtils.h (digamos que no 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 implemente esas funciones, necesitará la definición de la estructura, por lo que debe incluir el archivo Plop.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

Creo que el compilador de C originalmente tenía un pase en el que realizaba la construcción de tablas de símbolos y el análisis semántico juntos. Entonces, por ejemplo:

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

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

para evitar esto, usted dice:

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

Answer 5

Agregando a respuestas anteriores. La situación típica en la que la referencia directa es obligatoria es cuando una estructura foo contiene un puntero a una barra de estructura, y la barra contiene un puntero a foo (una dependencia circular entre declaraciones). La única forma de expresar esta situación en C es utilizar una declaración directa, es decir:

struct foo;

struct bar
{
   struct foo *f;
};

struct foo
{
   struct bar *b;
};

Answer 6

Las referencias directas permiten que el compilador de C haga menos pases 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 cumplían con menos eficiencia.