Zeiger auf Structs

Teil des Abschnitts Logik & Ablauf der C-Journey von Coddy. Lektion 44 von 63.

Da du nun sicher im Umgang mit Strukturen bist, ist es an der Zeit, sie mit einem weiteren leistungsfähigen C-Konzept zu kombinieren: Zeigern. Ebenso wie du Zeiger auf grundlegende Datentypen wie int oder char erstellen kannst, kannst du auch Zeiger erstellen, die die Adresse einer Strukturvariablen enthalten.

Die Syntax zum Deklarieren eines Zeigers auf eine Struktur folgt demselben Muster wie andere Zeigerdeklarationen:

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-Struktur speichern kann. Damit der Zeiger tatsächlich auf unsere Strukturvariable zeigt, verwendest du den Adressoperator:

ptr = &p1;

Jetzt enthält ptr die Speicheradresse der Strukturvariablen p1. Dies eröffnet neue Möglichkeiten für die Arbeit mit Strukturen, insbesondere wenn du sie an Funktionen übergibst oder den Speicher dynamisch verwaltest. Zeiger auf Strukturen sind unverzichtbar, um komplexere Datenstrukturen zu erstellen und effiziente C-Programme zu schreiben.

Aufgabe

Einfach

Erstelle ein C-Programm, das die Arbeit mit Zeigern auf Strukturen demonstriert. Dein Programm sollte:

Eine struct namens Product mit den folgenden Mitgliedern definieren:
- Eine Ganzzahl id zum Speichern der Produkt-ID
- Ein Zeichenarray name mit der Größe 25 zum Speichern des Produktnamens
- Eine Gleitkommazahl price zum Speichern des Produktpreises
- Eine Ganzzahl quantity zum Speichern der verfügbaren Menge
Erstelle in der main-Funktion eine Product-Variable namens item und initialisiere sie mit den folgenden Werten:
- ID: 501
- Name: "Laptop"
- Preis: 899.99
- Menge: 15
Deklariere einen Zeiger auf eine Product-Struktur namens itemPtr
Weise itemPtr mithilfe des Adressoperators die Adresse der Variable item zu
Gib die ursprünglichen Produktinformationen aus, indem du direkt auf die Strukturmitglieder zugreifst (unter Verwendung des Punktoperators) und dabei genau dieses Format verwendest:
- Original Product Info:
- ID: [id]
- Name: [name]
- Price: [price]
- Quantity: [quantity]
Gib dieselben Produktinformationen aus, indem du über den Zeiger auf die Strukturmitglieder zugreifst (unter Verwendung des Dereferenzierungsoperators und der Punktnotation: (*itemPtr).member) und dabei genau dieses Format verwendest:
- Product Info via Pointer:
- ID: [id]
- Name: [name]
- Price: [price]
- Quantity: [quantity]
Überprüfe, ob der Zeiger korrekt auf die Struktur zeigt, indem du die Speicheradressen in genau diesem Format ausgibst:
- Address of item: [address]
- Value of itemPtr: [address]
- Address verification: [result]

Gib bei der Adressüberprüfung Match aus, wenn die Adressen gleich sind, oder No Match, wenn sie unterschiedlich sind.

Diese Aufgabe prüft dein Verständnis der Deklaration eines Zeigers auf eine Struktur, der Adresszuweisung mithilfe des Adressoperators und des Zugriffs auf Strukturmitglieder über Zeiger mithilfe des Dereferenzierungsoperators in Kombination mit der Punktnotation. Außerdem überprüfst du, ob der Zeiger korrekt die Adresse der Strukturvariablen enthält.

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