Was ist der Unterschied in der Verwendung von Strukturzeiger und Strukturvariablen?

Question

struct Book { 
    int i; 
} variable, *ptr; 

während struct memebers Zugriff auf die wir verwenden variable.i oder ptr-> i meine Frage ist, was ist der Unterschied zwischen/Verwendung von variablen und * ptr

Answer 1

einen Hund vorstellen.

Jetzt stellen Sie sich eine Hundeleine vor.

Stellen Sie sich nun den Hund vor, der an der Leine befestigt ist.

Die Leine repräsentiert einen Zeiger auf den Hund. Wenn du einen Zeiger (Leine) erstellst und keine auch eine Struktur hast, auf die du (Hund) zeigen kannst, dann kannst du nicht in den Park gehen und Frisbee spielen.

Wenn Sie eine Struktur haben, aber keinen Zeiger haben, können Sie immer noch viele Dinge tun.

Die Verwendung eines Zeigers erfordert eine Struktur, auf die verwiesen werden kann. Sie können entweder eine Struktur, erklären und dann darauf zeigen die & Operator, oder Sie können eine Funktion wie malloc oder calloc aufrufen, die zurückkehren wird dynamisch zugewiesenen Speicher, die Sie als Struktur verwenden können:

void demo() { 
    struct Book b1; 
    struct Book b2; 

    typedef struct Book * Bookptr; 

    Bookptr p; 

    // Assign pointer to existing object using address operator: 

    p = &b1; 
    p->i = 10; 
    p = &b2; 
    p->i = 12; 
    printf("Book 1 has i: %d, while Book 2 has i: %d\n", b1.i, b2.i); 

    // Use dynamically allocated memory 
    p = calloc(1, sizeof(struct Book)); 
    p->i = 3; 
    printf("Dynamic book has i: %d\n", p->i); 
    free(p); 
} 

Answer 2

variable wird Speicher zugeordnet und kann daher direkt beim Erstellen aufgerufen werden. Da der Speicher zum Zeitpunkt der Kompilierung angegeben ist, bedeutet die . der Compiler kann direkt die Werte in der Struktur Nachschlag ohne jede Art von in-direkten Springen

ptr wird nur ein Zeiger auf Speicher zu tun zu haben und nicht verwendet werden kann, bis zeigte auf etwas, das Speicher hat (oder Speicher über eine dynamische Speicherzuweisung gegeben hat). Der -> bedeutet, dass der Compiler zuerst den Speicher lesen und dann zum Speicherort springen muss.