tipos - ¿Qué es una referencia directa en C?

referencias en c++

Question

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

¿Puedo obtener un ejemplo?

Answer 1

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

El puntero se declara antes de que se defina 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 2

Creo que originalmente el compilador de C tenía un pase en el que combinaba la creación de tablas de símbolos 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, dices:

    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 3

Las referencias hacia adelante permiten al compilador C 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 4

Agregar a 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 forma de expresar esta situación en C es usar una declaración directa, es decir:

struct foo;

struct bar
{
   struct foo *f;
};

struct foo
{
   struct bar *b;
};

Answer 5

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 forma 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. Usted 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 6

Vea esta página en referencias hacia adelante . 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 los tipos de declaración y declarar las 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ás pidiendo cuando tratas con punteros y reenvía la declaración.