Quelle est la référence en avant en C?

Question

Qu'est-ce que la référence directe en C par rapport aux pointeurs?

Puis-je avoir un exemple?

Answer 1

Voir cette page sur références de renvoi . Je ne vois pas en quoi le référencement direct serait différent avec les pointeurs et avec d'autres types de points de vente.

Notez que vous pouvez transférer des types de déclaration et déclarer des variables qui pointent vers ce type:

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 {
    // ...
};

Je pense que c'est ce que vous demandez en ce qui concerne les pointeurs et la déclaration anticipée.

Answer 2

Je pense "référence avancée". en ce qui concerne les pointeurs signifie quelque chose comme ceci:

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

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

Le pointeur est déclaré avant que la structure vers laquelle il pointe ne soit définie.

Le compilateur peut s'en tirer, car le pointeur stocke une adresse et vous n'avez pas besoin de savoir à quelle adresse se trouve cette adresse pour réserver de la mémoire au pointeur.

Answer 3

La référence directe est lorsque vous déclarez un type mais ne le définissez pas.

Il vous permet d'utiliser le type par pointeur (ou référence pour C ++) mais vous ne pouvez pas déclarer une variable.

C’est une façon de dire au compilateur que quelque chose existe

Dites que vous avez une structure Plop définie dans Plop.h :

struct Plop
{
   int n;
   float f;
};

Maintenant, vous voulez ajouter des fonctions utilitaires qui fonctionnent avec cette structure. Vous créez un autre fichier PlopUtils.h (disons que vous ne pouvez pas modifier 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);

Maintenant, lorsque vous implémenterez ces fonctions, vous aurez besoin de la définition de la structure. Vous devez donc inclure le fichier Plop.h dans votre 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

Je pense que le compilateur C avait initialement une passe dans laquelle il a construit ensemble une table de symboles et une analyse sémantique. Ainsi, par exemple:

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

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

pour empêcher cela, vous dites:

    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 avait le même concept.

Answer 5

Ajout aux réponses précédentes. La situation typique dans laquelle la référence en aval est obligatoire est lorsqu'un struct foo contient un pointeur sur une barre de structure et que bar contient un pointeur sur foo (une dépendance circulaire entre des déclarations). La seule façon d’exprimer cette situation en C est d’utiliser une déclaration forward, c’est-à-dire:

struct foo;

struct bar
{
   struct foo *f;
};

struct foo
{
   struct bar *b;
};

Answer 6

Les références en aval permettent au compilateur C d'effectuer moins de passes et réduisent considérablement le temps de compilation. C’est probablement important il ya 20 ans, lorsque les ordinateurs étaient beaucoup plus lents et les ordinateurs moins efficaces.