Labor 5: Strukturen & Zeiger - Fortgeschrittene Algorithmen und Programmierung

← Zurück zur Übersicht

🎯 Lernziele

In diesem Labor lernen Sie:

Was Strukturen (structs) sind und wie man sie verwendet
Wie man auf Struktur-Komponenten zugreift (Punkt-Operator)
Was Zeiger (pointers) sind und wie sie funktionieren
Wie man Werte über Zeiger ändert (Dereferenzierung mit *)
Wie man mit mehreren Zeigern arbeitet

⚠️ Wichtige Hinweise

Strukturen werden vor der main()-Funktion definiert
Für Strings in Strukturen benötigen Sie #include <string.h>
Der Punkt-Operator . greift auf Struktur-Komponenten zu
&variable gibt die Adresse einer Variable zurück
*zeiger greift auf den Wert zu, auf den der Zeiger zeigt

📦 Teil 1: Strukturen

Lernen Sie, wie man zusammengehörige Daten in Strukturen organisiert

1 Ihre erste Struktur: Person

Beschreibung:

Erstellen Sie eine einfache Struktur für eine Person mit Name und Alter.

📋 Aufgabe

Definieren Sie eine Struktur Person mit:
- char name[50] - für den Namen
- int alter - für das Alter
Erstellen Sie eine Variable vom Typ struct Person
Weisen Sie den Namen "Anna" zu (mit strcpy())
Weisen Sie das Alter 25 zu
Geben Sie die Daten aus

💡 Hilfe

Struktur-Definition (vor main):

struct Person {
    char name[50];
    int alter;
};

Verwendung in main():

struct Person p1;
strcpy(p1.name, "Anna");
p1.alter = 25;

✅ Musterlösung

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

// Struktur-Definition vor main()
struct Person {
    char name[50];
    int alter;
};

int main() {
    // Variable vom Typ struct Person erstellen
    struct Person p1;

    // Werte zuweisen
    strcpy(p1.name, "Anna");  // String mit strcpy()
    p1.alter = 25;               // int direkt zuweisen

    // Ausgabe
    printf("Name: %s\n", p1.name);
    printf("Alter: %d Jahre\n", p1.alter);

    return 0;
}

Ausgabe:

Name: Anna
Alter: 25 Jahre

2 Struktur mit Initialisierung: Buch

Beschreibung:

Lernen Sie, wie Sie Strukturen direkt bei der Erstellung initialisieren können.

📋 Aufgabe

Erstellen Sie eine Struktur Buch mit:
- char titel[100]
- char autor[50]
- int seiten
Initialisieren Sie ein Buch direkt mit Werten:
- Titel: "C Programmierung"
- Autor: "Max Mustermann"
- Seiten: 450
Geben Sie alle Informationen aus

💡 Hilfe

Initialisierung mit geschweiften Klammern:

struct Buch b1 = {"C Programmierung", "Max Mustermann", 450};

Die Werte werden in der Reihenfolge der Struktur-Definition zugewiesen.

✅ Musterlösung

#include <stdio.h>

// Struktur-Definition
struct Buch {
    char titel[100];
    char autor[50];
    int seiten;
};

int main() {
    // Direkte Initialisierung mit geschweiften Klammern
    struct Buch b1 = {"C Programmierung", "Max Mustermann", 450};

    // Ausgabe
    printf("Titel: %s\n", b1.titel);
    printf("Autor: %s\n", b1.autor);
    printf("Seiten: %d\n", b1.seiten);

    return 0;
}

Ausgabe:

Titel: C Programmierung
Autor: Max Mustermann
Seiten: 450

3 Struktur mit Benutzereingabe: Auto

Beschreibung:

Erstellen Sie eine Struktur und füllen Sie sie mit Benutzereingaben.

📋 Aufgabe

Erstellen Sie eine Struktur Auto mit:
- char marke[50]
- char modell[50]
- int baujahr
Lesen Sie alle drei Werte vom Benutzer ein
Geben Sie die Informationen formatiert aus

⚠️ Wichtig bei scanf()

Strings: scanf("%s", auto1.marke) - OHNE &
int: scanf("%d", &auto1.baujahr) - MIT &

✅ Musterlösung

#include <stdio.h>

struct Auto {
    char marke[50];
    char modell[50];
    int baujahr;
};

int main() {
    struct Auto auto1;

    // Eingabe
    printf("Marke: ");
    scanf("%s", auto1.marke);     // Kein & bei Strings!

    printf("Modell: ");
    scanf("%s", auto1.modell);    // Kein & bei Strings!

    printf("Baujahr: ");
    scanf("%d", &auto1.baujahr); // & bei int!

    // Ausgabe
    printf("\n=== Auto-Informationen ===\n");
    printf("Marke: %s\n", auto1.marke);
    printf("Modell: %s\n", auto1.modell);
    printf("Baujahr: %d\n", auto1.baujahr);

    return 0;
}

Beispiel-Ausgabe:

Marke: BMW
Modell: X5
Baujahr: 2022

=== Auto-Informationen ===
Marke: BMW
Modell: X5
Baujahr: 2022

4 Mehrere Struktur-Variablen: Produkte

Beschreibung:

Erstellen Sie mehrere Variablen vom gleichen Struktur-Typ und vergleichen Sie sie.

📋 Aufgabe

Erstellen Sie eine Struktur Produkt mit:
- char name[50]
- double preis
- int lagerbestand
Erstellen Sie 3 verschiedene Produkte (initialisieren Sie sie direkt)
Geben Sie alle Produkte in einer Tabelle aus
Berechnen Sie den Gesamtwert aller Produkte (Preis × Lagerbestand)

✅ Musterlösung

#include <stdio.h>

struct Produkt {
    char name[50];
    double preis;
    int lagerbestand;
};

int main() {
    // Drei verschiedene Produkte erstellen
    struct Produkt p1 = {"Laptop", 899.99, 15};
    struct Produkt p2 = {"Maus", 29.99, 50};
    struct Produkt p3 = {"Tastatur", 79.99, 30};

    // Tabellarische Ausgabe
    printf("%-15s %10s %15s %15s\n",
           "Produkt", "Preis", "Lagerbestand", "Gesamtwert");
    printf("=================================================================\n");

    // Produkt 1
    printf("%-15s %10.2f EUR %15d %15.2f EUR\n",
           p1.name, p1.preis, p1.lagerbestand, p1.preis * p1.lagerbestand);

    // Produkt 2
    printf("%-15s %10.2f EUR %15d %15.2f EUR\n",
           p2.name, p2.preis, p2.lagerbestand, p2.preis * p2.lagerbestand);

    // Produkt 3
    printf("%-15s %10.2f EUR %15d %15.2f EUR\n",
           p3.name, p3.preis, p3.lagerbestand, p3.preis * p3.lagerbestand);

    // Gesamtwert berechnen
    double gesamtwert = (p1.preis * p1.lagerbestand) +
                         (p2.preis * p2.lagerbestand) +
                         (p3.preis * p3.lagerbestand);

    printf("=================================================================\n");
    printf("Gesamtwert aller Produkte: %.2f EUR\n", gesamtwert);

    return 0;
}

Ausgabe:

Produkt              Preis    Lagerbestand      Gesamtwert
=================================================================
Laptop             899.99 EUR              15       13499.85 EUR
Maus                29.99 EUR              50        1499.50 EUR
Tastatur            79.99 EUR              30        2399.70 EUR
=================================================================
Gesamtwert aller Produkte: 17399.05 EUR

🎯 Teil 2: Zeiger

Lernen Sie, wie man mit Zeigern indirekt auf Variablen zugreift

5 Ihr erster Zeiger

Erstellen Sie eine Integer-Variable zahl mit dem Wert 42. Erstellen Sie einen Zeiger ptr, der auf zahl zeigt. Geben Sie aus:

Den Wert von zahl
Die Adresse von zahl (mit &zahl)
Den Wert von ptr (die gespeicherte Adresse)
Den Wert, auf den ptr zeigt (mit *ptr)

💡 Hilfe

Zeiger deklarieren und initialisieren:

int zahl = 42;
int *ptr = &zahl;  // ptr zeigt auf zahl

Ausgabe:

%d für Werte
%p für Adressen (pointer)

✅ Musterlösung

#include <stdio.h>

int main() {
    int zahl = 42;
    int *ptr = &zahl;  // ptr zeigt auf zahl

    printf("Wert von zahl: %d\n", zahl);
    printf("Adresse von zahl: %p\n", &zahl);
    printf("Wert von ptr (Adresse): %p\n", ptr);
    printf("Wert, auf den ptr zeigt: %d\n", *ptr);

    return 0;
}

Erklärung:

&zahl gibt die Speicheradresse von zahl zurück
ptr speichert diese Adresse
*ptr greift auf den Wert zu, auf den ptr zeigt (= 42)
%p ist das Format für Pointer-Adressen (zeigt Adresse in hexadezimal)

6 Wert über Zeiger ändern

Erstellen Sie eine Variable alter = 20. Erstellen Sie einen Zeiger darauf. Ändern Sie den Wert von alter auf 25 über den Zeiger (mit *ptr = 25;). Geben Sie alter vor und nach der Änderung aus.

💡 Hilfe

Wert über Zeiger ändern (Dereferenzierung):

*ptr = 25; // Ändert den Wert, auf den ptr zeigt

✅ Musterlösung

#include <stdio.h>

int main() {
    int alter = 20;
    int *ptr = &alter;

    printf("Alter vorher: %d\n", alter);

    // Wert über Zeiger ändern
    *ptr = 25;

    printf("Alter nachher: %d\n", alter);

    return 0;
}

Erklärung:

*ptr = 25; dereferenziert den Zeiger und ändert den Wert an der Adresse, auf die er zeigt
Das ist äquivalent zu alter = 25;, aber über den Zeiger
Beide Ausgaben zeigen den gleichen Wert, weil ptr auf alter zeigt

7 Werte mit Zeigern tauschen

Erstellen Sie zwei Variablen x = 5 und y = 10. Tauschen Sie die Werte von x und y mithilfe von Zeigern und einer Hilfsvariable temp. Geben Sie x und y vor und nach dem Tauschen aus.

💡 Hilfe

Werte tauschen:

int temp = *ptr1;  // Wert von x speichern
*ptr1 = *ptr2;       // x = y
*ptr2 = temp;        // y = alter Wert von x

✅ Musterlösung

#include <stdio.h>

int main() {
    int x = 5;
    int y = 10;

    int *ptr1 = &x;
    int *ptr2 = &y;

    printf("Vorher: x = %d, y = %d\n", x, y);

    // Werte tauschen über Zeiger
    int temp = *ptr1;
    *ptr1 = *ptr2;
    *ptr2 = temp;

    printf("Nachher: x = %d, y = %d\n", x, y);

    return 0;
}

Erklärung:

temp = *ptr1; speichert den Wert von x (5) in temp
*ptr1 = *ptr2; kopiert den Wert von y (10) nach x
*ptr2 = temp; kopiert den alten Wert von x (5) nach y
Ergebnis: x = 10, y = 5

🎉 Zusammenfassung

Herzlichen Glückwunsch! Sie haben gelernt:

✅ Strukturen zu definieren und zu verwenden
✅ Auf Struktur-Komponenten mit dem Punkt-Operator zuzugreifen
✅ Strukturen zu initialisieren (direkt und mit Benutzereingabe)
✅ Zeiger zu deklarieren und zu verwenden
✅ Werte über Zeiger zu ändern (Dereferenzierung)
✅ Werte mit Zeigern zu tauschen

📚 Nächste Schritte

In den folgenden Vorlesungen und Laboren lernen Sie:

Vorlesung 9: Zeiger und Strukturen kombinieren (Pfeil-Operator ->)
Arrays von Strukturen
Funktionen mit Strukturen und Zeigern
Dynamische Speicherverwaltung (malloc, free)
Verkettete Listen und andere Datenstrukturen

← Zurück zur Übersicht

💻 Labor 5: Strukturen & Zeiger

🎯 Lernziele

⚠️ Wichtige Hinweise

📦 Teil 1: Strukturen

1 Ihre erste Struktur: Person

📋 Aufgabe

💡 Hilfe

✅ Musterlösung

2 Struktur mit Initialisierung: Buch

📋 Aufgabe

💡 Hilfe

✅ Musterlösung

3 Struktur mit Benutzereingabe: Auto

📋 Aufgabe

⚠️ Wichtig bei scanf()

✅ Musterlösung

4 Mehrere Struktur-Variablen: Produkte

📋 Aufgabe

✅ Musterlösung

🎯 Teil 2: Zeiger

5 Ihr erster Zeiger

💡 Hilfe

✅ Musterlösung

Erklärung:

6 Wert über Zeiger ändern

💡 Hilfe

✅ Musterlösung

Erklärung:

7 Werte mit Zeigern tauschen

💡 Hilfe

✅ Musterlösung

Erklärung:

🎉 Zusammenfassung

📚 Nächste Schritte