Was ist Vorwärts-Referenz in C?

Question

Was ist Vorwärts-Referenz in C in Bezug auf Zeiger?

Kann ich ein Beispiel nennen?

Answer 1

Sehen Sie diese Seite auf Vorwärtsreferenzen . Ich sehe nicht, wie es weiter Referenzierung mit Zeigern wäre anders und mit anderen PoD-Typen.

Beachten Sie, dass Sie Typen deklarieren weiterleiten kann, und Variablen deklarieren, die Zeiger auf diese Art sind:

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

Ich denke, das ist, was Sie fragen, wann mit Zeigern und Forward-Deklaration zu tun.

Answer 2

Ich denke, „Vorwärts-Referenz“ in Bezug auf Zeiger so etwas wie dies bedeutet:

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

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

Der Zeiger vor der Struktur deklariert wird er zeigt definiert ist.

Der Compiler kann mit diesem, weil die Zeiger speichert eine Adresse weg, und Sie brauchen nicht zu wissen, was an dieser Adresse ist der Speicher für den Zeiger zu reservieren.

Answer 3

Weiterleiten Referenz ist, wenn Sie einen Typ deklarieren, aber nicht definieren es.

Es ermöglicht Ihnen, die Art von Zeiger (oder Referenz für C ++) zu verwenden, aber Sie können eine Variable nicht deklarieren.

Dies ist ein Weg, um den Compiler zu sagen, dass etwas existiert

Sagen Sie, dass Sie eine Plop Struktur definiert in Plop.h :

struct Plop
{
   int n;
   float f;
};

Sie möchten nun einige Hilfsfunktionen hinzuzufügen, die mit dieser Struktur funktioniert. Sie erstellen eine andere Datei PlopUtils.h (sagen wir, Sie nicht Plop.h ändern können):

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);

Nun, wenn Sie diese Funktion implementieren, müssen Sie die Strukturdefinition benötigen, so dass Sie die Plop.h Datei enthalten müssen in der 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

Ich denke, der C-Compiler hatte ursprünglich einen Pass, in dem es Symboltabelle Gebäude hat und semantische Analyse zusammen. So zum Beispiel:

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

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

Um dies zu verhindern, sagen Sie:

    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 hatte das gleiche Konzept.

Answer 5

Hinzufügen zur vorherigen Antworten. Die typische Situation, in der Vorwärts-Referenz ist obligatorisch ist, wenn ein struct foo einen Zeiger auf eine struct bar enthält, und bar enthält einen Zeiger auf foo (eine kreisförmige Abhängigkeit zwischen Erklärungen). Der einzige Weg, um diese Situation in C auszudrücken, ist eine Vorwärts-Deklaration zu verwenden, das heißt:.

struct foo;

struct bar
{
   struct foo *f;
};

struct foo
{
   struct bar *b;
};

Answer 6

Vorwärtsreferenzen erlauben C-Compiler weniger Pässe zu tun und reduziert deutlich Kompilierung. Es ist wahrscheinlich vor etwa 20 Jahren wichtig, wenn die Computer waren viel langsamer und compliers weniger effizient.