Der Pfeiloperator (->)

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

Beim Arbeiten mit Zeigern auf Structs erfordert der Zugriff auf die Struct-Member eine spezielle Syntax. Während man den Dereferenzierungsoperator und die Punktnotation zusammen verwenden könnte, bietet C einen bequemeren Operator speziell für diesen Zweck an: den Pfeiloperator (->).

Der Pfeil-Operator ermöglicht es Ihnen, auf Struct-Member über einen Pointer auf eine saubere, lesbare Weise zuzugreifen:

ptr->member

Dies ist äquivalent zum Schreiben von (*ptr).member, aber viel prägnanter.

So sieht es in der Praxis aus:

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

// Verwendung des Pfeil-Operators
printf("x = %d, y = %d\n", ptr->x, ptr->y);

// Dies ist dasselbe wie:
printf("x = %d, y = %d\n", (*ptr).x, (*ptr).y);

Der Pfeil-Operator macht Ihren Code sauberer und einfacher zu lesen, insbesondere bei der Arbeit mit komplexen Datenstrukturen. Er ist der Standardweg, um in der C-Programmierung über Pointer auf struct-Elemente zuzugreifen.

Aufgabe

Einfach

Erstellen Sie ein C-Programm, das die Verwendung des Pfeiloperators zum Zugriff auf Struct-Elemente über Pointer demonstriert. Ihr Programm sollte Folgendes tun:

Definieren Sie ein struct namens Book mit den folgenden Elementen:
- Ein Integer id zum Speichern der Buch-ID
- Ein Zeichen-Array title mit der Größe 40 zum Speichern des Buchtitels
- Ein Zeichen-Array author mit der Größe 30 zum Speichern des Autorennamens
- Ein Float price zum Speichern des Buchpreises
- Ein Integer pages zum Speichern der Seitenanzahl
Erstellen Sie in der main-Funktion eine Book-Variable namens myBook
Deklarieren Sie einen Pointer auf ein Book-Struct namens bookPtr
Weisen Sie die Adresse von myBook dem bookPtr zu
Lesen Sie die folgenden Eingabewerte ein und weisen Sie diese den Struct-Elementen unter Verwendung des Pfeiloperators über den Pointer zu:
- Lesen Sie einen Integer für die ID und weisen Sie ihn mit bookPtr->id zu
- Lesen Sie einen String für den Titel und weisen Sie ihn mit bookPtr->title zu
- Lesen Sie einen String für den Autor und weisen Sie ihn mit bookPtr->author zu
- Lesen Sie einen Float für den Preis und weisen Sie ihn mit bookPtr->price zu
- Lesen Sie einen Integer für die Seitenanzahl und weisen Sie ihn mit bookPtr->pages zu
Führen Sie nach dem Einlesen aller Werte die folgenden Operationen mit dem Pfeiloperator durch:
- Wenden Sie einen Rabatt von 10% auf den Preis an: bookPtr->price = bookPtr->price * 0.9;
- Fügen Sie 50 Bonusseiten hinzu: bookPtr->pages += 50;
Geben Sie die Buchinformationen unter Verwendung des Pfeiloperators für den Zugriff auf jedes Element in genau diesem Format aus:
- Book Information:
- ID: [id]
- Title: [title]
- Author: [author]
- Price: [price]
- Pages: [pages]
Berechnen und geben Sie den Preis pro Seite unter Verwendung des Pfeiloperators im Format Price per page: [price_per_page] aus

Diese Herausforderung testet Ihr Verständnis des Pfeiloperators für den Zugriff auf Struct-Elemente über Pointer. Sie üben die Syntax ptr->member sowohl für das Lesen von als auch für das Schreiben in Struct-Elemente und demonstrieren damit, dass dies äquivalent zu (*ptr).member ist, aber wesentlich komfortabler und lesbarer.

Spickzettel

Der Pfeiloperator (->) bietet eine bequeme Möglichkeit, über einen Zeiger auf Struktur-Member zuzugreifen:

ptr->member

Dies ist äquivalent zu (*ptr).member, aber prägnanter und lesbarer.

Beispielhafte Verwendung:

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

// Verwendung des Pfeiloperators
printf("x = %d, y = %d\n", ptr->x, ptr->y);

// Dies ist dasselbe wie:
printf("x = %d, y = %d\n", (*ptr).x, (*ptr).y);

Probier es selbst

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

// TODO: Definieren Sie hier das Book-Struct

int main() {
    // TODO: Erstellen Sie eine Book-Variable namens myBook
    
    // TODO: Deklarieren Sie einen Zeiger auf Book namens bookPtr
    
    // TODO: Weisen Sie die Adresse von myBook bookPtr zu
    
    // Eingabewerte lesen
    int id;
    char title[40];
    char author[30];
    float price;
    int pages;
    
    scanf("%d", &id);
    scanf("%s", title);
    scanf("%s", author);
    scanf("%f", &price);
    scanf("%d", &pages);
    
    // TODO: Weisen Sie die Eingabewerte den Struct-Elementen mit dem Pfeil-Operator zu
    
    // TODO: Wenden Sie 10 % Rabatt auf den Preis mit dem Pfeil-Operator an
    
    // TODO: Fügen Sie 50 Bonusseiten mit dem Pfeil-Operator hinzu
    
    // TODO: Buchinformationen mit dem Pfeil-Operator ausgeben
    
    // TODO: Preis pro Seite mit dem Pfeil-Operator berechnen und ausgeben
    
    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