Zeiger auf Structs

Teil des Abschnitts Logic & Flow der C-Journey von Coddy — Lektion 44 von 63.

Nachdem Sie nun mit der Arbeit mit Structs vertraut sind, ist es an der Zeit, diese mit einem weiteren mächtigen C-Konzept zu kombinieren: Pointern. Genauso wie Sie Pointer auf Basisdatentypen wie int oder char erstellen können, können Sie auch Pointer erstellen, die die Adresse einer Struct-Variable speichern.

Die Syntax für die Deklaration eines Pointers auf ein Struct folgt demselben Muster wie andere Pointer-Deklarationen:

struct StructureName *pointerName;

Zum Beispiel unter Verwendung unserer vertrauten Point-Struktur:

struct Point p1 = {10, 20};
struct Point *ptr;

Dies erstellt einen Zeiger namens ptr, der die Adresse einer Point-Struct speichern kann. Damit der Zeiger tatsächlich auf unsere Struct-Variable zeigt, verwenden Sie den Adressoperator:

ptr = &p1;

Jetzt enthält ptr die Speicheradresse der p1 struct-Variable. Dies eröffnet neue Möglichkeiten für die Arbeit mit structs, insbesondere bei der Übergabe an Funktionen oder der dynamischen Speicherverwaltung. Pointer auf structs sind essenziell für den Aufbau komplexerer Datenstrukturen und das Schreiben effizienter C-Programme.

Aufgabe

Einfach

Erstellen Sie ein C-Programm, das die Arbeit mit Pointern auf Structs demonstriert. Ihr Programm sollte:

Definieren Sie ein struct namens Product mit den folgenden Membern:
- Ein Integer id, um die Produkt-ID zu speichern
- Ein Character-Array name mit der Größe 25, um den Produktnamen zu speichern
- Ein Float price, um den Produktpreis zu speichern
- Ein Integer quantity, um die verfügbare Menge zu speichern
Erstellen Sie in der main-Funktion eine Product-Variable namens item und initialisieren Sie diese mit den folgenden Werten:
- ID: 501
- Name: "Laptop"
- Price: 899.99
- Quantity: 15
Deklarieren Sie einen Pointer auf ein Product-Struct namens itemPtr
Weisen Sie die Adresse der item-Variable dem itemPtr unter Verwendung des Adressoperators zu
Geben Sie die ursprünglichen Produktinformationen aus, indem Sie direkt auf die Struct-Member zugreifen (unter Verwendung des Punktoperators), und zwar in diesem exakten Format:
- Original Product Info:
- ID: [id]
- Name: [name]
- Price: [price]
- Quantity: [quantity]
Geben Sie dieselben Produktinformationen aus, indem Sie über den Pointer auf die Struct-Member zugreifen (unter Verwendung des Dereferenzierungsoperators und der Punktnotation: (*itemPtr).member), und zwar in diesem exakten Format:
- Product Info via Pointer:
- ID: [id]
- Name: [name]
- Price: [price]
- Quantity: [quantity]
Überprüfen Sie, ob der Pointer korrekt auf das Struct zeigt, indem Sie die Speicheradressen in diesem exakten Format ausgeben:
- Address of item: [address]
- Value of itemPtr: [address]
- Address verification: [result]

Geben Sie für die Adressverifizierung Match aus, wenn die Adressen gleich sind, oder No Match, wenn sie unterschiedlich sind.

Diese Herausforderung testet Ihr Verständnis der Deklaration von Pointern auf Structs, der Adresszuweisung mit dem Adressoperator und des Zugriffs auf Struct-Member über Pointer unter Verwendung des Dereferenzierungsoperators in Kombination mit der Punktnotation. Sie werden außerdem verifizieren, dass der Pointer korrekt die Adresse der Struct-Variable enthält.

Spickzettel

Sie können Zeiger auf Structs mit derselben Syntax wie andere Zeigerdeklarationen erstellen:

struct StructureName *pointerName;

Um einen Zeiger auf eine Struct-Variable zeigen zu lassen, verwenden Sie den Adressoperator:

struct Point p1 = {10, 20};
struct Point *ptr;
ptr = &p1;

Greifen Sie auf Struct-Member über einen Zeiger zu, indem Sie den Dereferenzierungsoperator und die Punktnotation verwenden:

(*ptr).member

Probier es selbst

#include <stdio.h>
#include <string.h>

// TODO: Definieren Sie hier das Product-Struct

int main() {
    // TODO: Schreiben Sie hier Ihren Code
    // 1. Erstellen und initialisieren Sie die Product-Variable 'item'
    // 2. Deklarieren Sie einen Zeiger auf Product namens 'itemPtr'
    // 3. Weisen Sie die Adresse von 'item' an 'itemPtr' zu
    // 4. Geben Sie die ursprünglichen Produktinformationen mit dem Punkt-Operator aus
    // 5. Geben Sie die Produktinformationen über den Zeiger mit (*itemPtr).member aus
    // 6. Adressen ausgeben und überprüfen
    
    return 0;
}

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Logic & Flow

2Pointer und Arrays

Array-Namen als Pointer Array-Elemente - Pointer Pointer-Arithmetik Pointer vergleichen Wiederholung: Array-Durchlauf mit Pointern

5Zeiger und Funktionen

Wertübergabe (Pass-by-Value)Zeiger an Funktionen übergeben Variablen über Zeiger ändern Ein klassisches Beispiel: Swap Arrays an Funktionen übergeben Zusammenfassung: Zeiger als Funktionsargumente

8Structs und Zeiger

Zeiger auf StructsDer Pfeiloperator (->)Structs per Wert übergeben Übergabe von Struct-Zeigern Dynamische Allokation von Structs Zusammenfassung: Struct ändern - Ptr

11Finale Wiederholungsaufgaben

Wiederholung: Dynamische String-Konkatenation Wiederholung: Array von Structs Wiederholung: Wortfrequenz-Zähler