Labor 2: Type Casting, Konstanten und Operatoren

Fortgeschrittene Algorithmen und Programmierung • Wintersemester 2025/26
⏱️ Dauer: 180 Minuten (3 Stunden)
🏠 Zurück zur Startseite

📋 Laborziele

🔄 Type Casting

Verstehen und anwenden von impliziter und expliziter Typkonvertierung

💎 Konstanten

Arbeiten mit const und #define für unveränderliche Werte

🎲 Zufallszahlen

Generieren von Pseudo-Zufallszahlen mit rand() und srand()

⚡ Operatoren

Kombinierte Zuweisungen, Inkrement/Dekrement und Operator-Prioritäten

ℹ️ Wichtige Hinweise

1 Integer-Division Problem lösen

Ziel: Verstehen Sie das Problem der Ganzzahldivision und beheben Sie es mit Type Casting.

📝 Aufgabenstellung:

Gegeben ist folgender fehlerhafter Code:

#include <stdio.h>

int main() {
    int pruefungen = 5;
    int bestandenePruefungen = 4;

    double erfolgsquote = bestandenePruefungen / pruefungen;

    printf("Erfolgsquote: %.2lf%%\n", erfolgsquote * 100);

    return 0;
}

Problem: Die Erfolgsquote wird als 0.00% ausgegeben, obwohl sie 80% sein sollte!

  1. Erklären Sie, warum das Programm falsch rechnet
  2. Beheben Sie den Fehler mit Type Casting
  3. Testen Sie mit verschiedenen Werten
  4. Bonus: Berechnen Sie auch den Durchschnitt mehrerer Noten
💡 Tipp: Integer-Division: 4 / 5 = 0 (nicht 0.8!). Verwenden Sie (double) für das Casting.

🎯 Erwartetes Ergebnis:

Erfolgsquote: 80.00%
🔒 Musterlösung
Falsches Passwort!
#include <stdio.h>

int main() {
    int pruefungen = 5;
    int bestandenePruefungen = 4;

    // Lösung: Cast zu double VOR der Division
    double erfolgsquote = (double)bestandenePruefungen / pruefungen;

    printf("Erfolgsquote: %.2lf%%\n", erfolgsquote * 100);

    // Bonus: Durchschnitt berechnen
    int note1 = 85, note2 = 90, note3 = 78, note4 = 92;
    int summe = note1 + note2 + note3 + note4;
    double durchschnitt = (double)summe / 4;

    printf("Durchschnitt der Noten: %.2lf\n", durchschnitt);

    return 0;
}

Erklärung: Bei 4 / 5 sind beide Operanden int, daher Integer-Division → Ergebnis 0. Mit (double)4 / 5 wird 4 zu double konvertiert, dann wird die Division als Kommazahl durchgeführt → Ergebnis 0.8. Der Cast muss VOR der Division erfolgen!

2 Konstanten richtig einsetzen

Ziel: Arbeiten mit const und #define für mathematische Konstanten.

📝 Aufgabenstellung:

Erstellen Sie ein Programm, das geometrische Berechnungen durchführt:

  1. Definieren Sie PI als Konstante (einmal mit const, einmal mit #define)
  2. Berechnen Sie für einen Radius (Benutzereingabe):
    • Kreisumfang: 2 * π * r
    • Kreisfläche: π * r²
    • Kugelvolumen: (4/3) * π * r³
  3. Verwenden Sie aussagekräftige Konstantennamen in GROSSBUCHSTABEN
  4. Bonus: Definieren Sie auch die Mehrwertsteuer als Konstante (0.19) und berechnen Sie Bruttopreise
💡 Tipp:
const double PI = 3.14159265;
#define MEHRWERTSTEUER 0.19

🎯 Erwartetes Ergebnis:

Radius eingeben: 5
Umfang: 31.42
Fläche: 78.54
Volumen: 523.60
🔒 Musterlösung
Falsches Passwort!
#include <stdio.h>

// Konstanten mit #define (Präprozessor)
#define PI 3.14159265
#define MEHRWERTSTEUER 0.19

int main() {
    double radius;

    printf("Radius eingeben: ");
    scanf("%lf", &radius);

    // Berechnungen
    double umfang = 2 * PI * radius;
    double flaeche = PI * radius * radius;
    double volumen = (4.0 / 3.0) * PI * radius * radius * radius;

    printf("\nKreis-Berechnungen:\n");
    printf("Umfang: %.2lf\n", umfang);
    printf("Fläche: %.2lf\n", flaeche);
    printf("Volumen der Kugel: %.2lf\n", volumen);

    // Bonus: Mehrwertsteuer
    double nettopreis = 100.0;
    double bruttopreis = nettopreis * (1 + MEHRWERTSTEUER);

    printf("\nMehrwertsteuer-Rechnung:\n");
    printf("Netto: %.2lf EUR\n", nettopreis);
    printf("Brutto: %.2lf EUR\n", bruttopreis);

    // Versuch, Konstante zu ändern (wird nicht kompilieren)
    // PI = 3.14;  // ❌ Fehler bei #define
    // E = 2.72;   // ❌ Compiler-Fehler bei const

    return 0;
}

Erklärung: const double ist typsicher und respektiert Scope - bevorzugen Sie es! #define ist Text-Ersetzung ohne Typ. Achten Sie bei Brüchen auf 4.0 / 3.0 statt 4 / 3 (Integer-Division!). Konstantennamen werden traditionell in GROSSBUCHSTABEN geschrieben.

3 Würfel-Simulator mit Zufallszahlen

Ziel: Generieren Sie echte Pseudo-Zufallszahlen und simulieren Sie Würfelwürfe.

📝 Aufgabenstellung:

Erstellen Sie einen Würfel-Simulator:

  1. Initialisieren Sie den Zufallsgenerator mit srand(time(NULL))
  2. Simulieren Sie 10 Würfelwürfe (Zahlen 1-6)
  3. Zählen Sie, wie oft jede Zahl gewürfelt wurde (verwenden Sie 6 separate Variablen)
  4. Geben Sie eine Statistik mit Prozentangaben aus
💡 Tipp:
#include <stdlib.h>  // für rand() und srand()
#include <time.h>    // für time()

int wuerfel = rand() % 6 + 1;  // Zahl zwischen 1 und 6

// Nutzen Sie separate Zähler-Variablen:
int count1 = 0, count2 = 0, count3 = 0, count4 = 0, count5 = 0, count6 = 0;

🎯 Erwartetes Ergebnis:

🎲 Würfel-Simulator
==================
Würfe: 4 2 6 1 5 3 4 6 2 1

Statistik:
1: 2x (20%)
2: 2x (20%)
3: 1x (10%)
4: 2x (20%)
5: 1x (10%)
6: 2x (20%)
🔒 Musterlösung
Falsches Passwort!
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
    // Zufallsgenerator initialisieren (EINMAL am Anfang!)
    srand(time(NULL));

    printf("🎲 Würfel-Simulator\n");
    printf("==================\n");

    // Zähler für jede Zahl (1-6)
    int count1 = 0, count2 = 0, count3 = 0;
    int count4 = 0, count5 = 0, count6 = 0;
    int anzahlWuerfe = 10;

    printf("Würfe: ");
    for (int i = 0; i < anzahlWuerfe; i++) {
        int wurf = rand() % 6 + 1;
        printf("%d ", wurf);

        // Zählen mit if-else
        if (wurf == 1) count1++;
        else if (wurf == 2) count2++;
        else if (wurf == 3) count3++;
        else if (wurf == 4) count4++;
        else if (wurf == 5) count5++;
        else if (wurf == 6) count6++;
    }
    printf("\n\n");

    // Statistik ausgeben
    printf("Statistik:\n");
    double prozent1 = (double)count1 / anzahlWuerfe * 100;
    double prozent2 = (double)count2 / anzahlWuerfe * 100;
    double prozent3 = (double)count3 / anzahlWuerfe * 100;
    double prozent4 = (double)count4 / anzahlWuerfe * 100;
    double prozent5 = (double)count5 / anzahlWuerfe * 100;
    double prozent6 = (double)count6 / anzahlWuerfe * 100;

    printf("1: %dx (%.0lf%%)\n", count1, prozent1);
    printf("2: %dx (%.0lf%%)\n", count2, prozent2);
    printf("3: %dx (%.0lf%%)\n", count3, prozent3);
    printf("4: %dx (%.0lf%%)\n", count4, prozent4);
    printf("5: %dx (%.0lf%%)\n", count5, prozent5);
    printf("6: %dx (%.0lf%%)\n", count6, prozent6);

    return 0;
}

Erklärung: srand(time(NULL)) nutzt aktuelle Zeit als Seed → jedes Mal andere Zahlen. rand() % 6 ergibt 0-5, + 1 verschiebt zu 1-6. Wir nutzen 6 separate Zähler-Variablen (count1 bis count6) um zu zählen, wie oft jede Zahl vorkam. Mit if-else prüfen wir jeden Wurf und erhöhen den entsprechenden Zähler.

4 Kombinierte Operatoren in der Praxis

Ziel: Nutzen Sie kombinierte Zuweisungen und Inkrement/Dekrement effizient.

📝 Aufgabenstellung:

Erstellen Sie ein Punkte-System für ein Spiel:

  1. Startwert: 100 Punkte
  2. Implementieren Sie folgende Aktionen:
    • += 50: Bonus einsammeln
    • -= 30: Schaden nehmen
    • *= 2: Power-Up (Punkte verdoppeln)
    • /= 2: Bestrafung (Punkte halbieren)
    • ++: Kleiner Bonus
    • --: Kleiner Malus
  3. Führen Sie mehrere Aktionen durch und zeigen Sie nach jeder den aktuellen Punktestand
  4. Bonus: Erstellen Sie ein interaktives Spiel, bei dem der Benutzer Aktionen wählen kann
💡 Tipp:
punkte += 50;   // punkte = punkte + 50
punkte++;       // punkte = punkte + 1

🎯 Erwartetes Ergebnis:

Start: 100 Punkte
+ Bonus gesammelt: 150 Punkte
+ Power-Up aktiviert: 300 Punkte
- Schaden erhalten: 270 Punkte
+ Kleiner Bonus: 271 Punkte
🔒 Musterlösung
Falsches Passwort!
#include <stdio.h>

int main() {
    int punkte = 100;

    printf("🎮 Punkte-System\n");
    printf("================\n");
    printf("Start: %d Punkte\n", punkte);

    // Verschiedene Operationen
    punkte += 50;
    printf("+ Bonus gesammelt (+50): %d Punkte\n", punkte);

    punkte *= 2;
    printf("+ Power-Up aktiviert (x2): %d Punkte\n", punkte);

    punkte -= 30;
    printf("- Schaden erhalten (-30): %d Punkte\n", punkte);

    punkte++;
    printf("+ Kleiner Bonus (+1): %d Punkte\n", punkte);

    punkte /= 2;
    printf("- Bestrafung (/2): %d Punkte\n", punkte);

    // Bonus: Interaktives Spiel
    printf("\n🎮 Interaktives Spiel\n");
    printf("=====================\n");

    char weiter = 'j';
    punkte = 100;

    while (weiter == 'j' || weiter == 'J') {
        printf("\nAktuelle Punkte: %d\n", punkte);
        printf("Wähle Aktion:\n");
        printf("  1: Bonus (+50)\n");
        printf("  2: Schaden (-30)\n");
        printf("  3: Power-Up (x2)\n");
        printf("  4: Bestrafung (/2)\n");

        int aktion;
        printf("Aktion: ");
        scanf("%d", &aktion);

        switch (aktion) {
            case 1:
                punkte += 50;
                printf("✅ Bonus gesammelt!\n");
                break;
            case 2:
                punkte -= 30;
                printf("❌ Schaden erhalten!\n");
                break;
            case 3:
                punkte *= 2;
                printf("⚡ Power-Up aktiviert!\n");
                break;
            case 4:
                punkte /= 2;
                printf("💥 Bestrafung!\n");
                break;
            default:
                printf("Ungültige Aktion!\n");
        }

        printf("Weiter spielen? (j/n): ");
        scanf(" %c", &weiter);
    }

    printf("\nEndstand: %d Punkte\n", punkte);
    printf("Spiel beendet!\n");

    return 0;
}

Erklärung: Kombinierte Operatoren sind Kurzform: x += 5 statt x = x + 5. ++ erhöht um 1, -- verringert um 1. Switch-Statement ist ideal für Menü-Auswahl. Beachten Sie das Leerzeichen in scanf(" %c", &weiter) um Whitespace zu überspringen!

5 Zufalls-Zahlenraten-Spiel ⭐ BONUS

Ziel: Kombinieren Sie alles - Type Casting, Konstanten, Zufallszahlen und Operatoren!

📝 Aufgabenstellung:

Erstellen Sie ein vollständiges Zahlenraten-Spiel:

  1. Das Programm wählt eine Zufallszahl zwischen 1 und 100
  2. Der Spieler hat maximal 7 Versuche
  3. Nach jedem Versuch gibt das Programm Hinweise:
    • "Zu hoch!" oder "Zu niedrig!"
    • Wie viele Versuche noch übrig sind
  4. Bei Erfolg: Zeige die Anzahl der benötigten Versuche
  5. Bei Misserfolg: Zeige die richtige Zahl
  6. Bonus:
    • Punktesystem: 100 Punkte - (Versuche * 10)
    • "Weiter spielen?" Option
    • Statistik über alle Spiele
💡 Tipp:
const int MAX_VERSUCHE = 7;
int geheimzahl = rand() % 100 + 1;  // 1 bis 100

🎯 Erwartetes Ergebnis:

🎯 Zahlenraten-Spiel
====================
Ich habe mir eine Zahl zwischen 1 und 100 ausgedacht.
Du hast 7 Versuche!

Versuch 1/7: 50
Zu niedrig!

Versuch 2/7: 75
Zu hoch!

Versuch 3/7: 63
Richtig! Du hast gewonnen! 🎉
Benötigte Versuche: 3
Punkte: 70
🔒 Musterlösung
Falsches Passwort!
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>

#define MIN_ZAHL 1
#define MAX_ZAHL 100
#define MAX_PUNKTE 100

int main() {
    // Zufallsgenerator initialisieren
    srand(time(NULL));

    const int MAX_VERSUCHE = 7;
    char weiter;

    // Statistik-Variablen
    int gespielteSpiele = 0;
    int gewonneneSpiele = 0;
    int gesamtVersuche = 0;

    do {
        gespielteSpiele++;

        // Neue Zufallszahl
        int geheimzahl = rand() % (MAX_ZAHL - MIN_ZAHL + 1) + MIN_ZAHL;

        printf("\n🎯 Zahlenraten-Spiel (Runde %d)\n", gespielteSpiele);
        printf("====================\n");
        printf("Ich habe mir eine Zahl zwischen %d und %d ausgedacht.\n",
               MIN_ZAHL, MAX_ZAHL);
        printf("Du hast %d Versuche!\n\n", MAX_VERSUCHE);

        bool gewonnen = false;
        int versuch;

        for (int i = 1; i <= MAX_VERSUCHE; i++) {
            printf("Versuch %d/%d: ", i, MAX_VERSUCHE);
            scanf("%d", &versuch);

            if (versuch == geheimzahl) {
                gewonnen = true;
                gewonneneSpiele++;
                gesamtVersuche += i;

                int punkte = MAX_PUNKTE - (i * 10);

                printf("\n🎉 Richtig! Du hast gewonnen!\n");
                printf("Benötigte Versuche: %d\n", i);
                printf("Punkte: %d\n", punkte);
                break;
            } else if (versuch < geheimzahl) {
                printf("Zu niedrig! ");
                if (i < MAX_VERSUCHE) {
                    printf("Noch %d Versuche übrig.\n", MAX_VERSUCHE - i);
                }
            } else {
                printf("Zu hoch! ");
                if (i < MAX_VERSUCHE) {
                    printf("Noch %d Versuche übrig.\n", MAX_VERSUCHE - i);
                }
            }

            if (!gewonnen && i == MAX_VERSUCHE) {
                printf("\n❌ Leider verloren! Die Zahl war: %d\n", geheimzahl);
            }
        }

        // Statistik
        printf("\n📊 Statistik:\n");
        printf("Gespielte Spiele: %d\n", gespielteSpiele);
        printf("Gewonnene Spiele: %d\n", gewonneneSpiele);
        if (gewonneneSpiele > 0) {
            double durchschnittVersuche = (double)gesamtVersuche / gewonneneSpiele;
            printf("Durchschnittliche Versuche: %.1lf\n", durchschnittVersuche);
        }
        double gewinnrate = (double)gewonneneSpiele / gespielteSpiele * 100;
        printf("Gewinnrate: %.1lf%%\n", gewinnrate);

        printf("\nNochmal spielen? (j/n): ");
        scanf(" %c", &weiter);

    } while (weiter == 'j' || weiter == 'J');

    printf("\n👋 Danke fürs Spielen!\n");

    return 0;
}

Erklärung: Dies kombiniert alle Konzepte: #define für Konstanten, const für MAX_VERSUCHE, rand() mit richtiger Formel für Bereich, Type Casting für Prozentberechnung, kombinierte Operatoren (+=, ++), und Kontrollstrukturen. Die Formel rand() % (MAX - MIN + 1) + MIN erzeugt Zahlen im gewünschten Bereich.

💡 Wichtige Konzepte im Überblick

Type Casting

// FALSCH: Integer-Division
double x = 5 / 2;        // x = 2.0

// RICHTIG: Mit Cast
double y = (double)5 / 2; // y = 2.5

Konstanten

const double PI = 3.14159;  // Bevorzugt
#define MAX 100             // Präprozessor

Zufallszahlen

srand(time(NULL));           // Einmal
int zahl = rand() % 100 + 1; // 1 bis 100

Kombinierte Operatoren

x += 5;   // x = x + 5
x++;      // x = x + 1
x *= 2;   // x = x * 2

🎯 Ziel des Labors

✅ Was Sie erreichen sollten

🎓 Viel Erfolg!

Type Casting, Konstanten, Zufallszahlen und Operatoren - essenzielle C-Konzepte!

💡 Wir programmieren in C - alle Musterlösungen sind in C!

Bei Fragen: Raum 308 • 📞 +49 30 5019-2664

🔐 Musterlösungen - Passwörter

Hinweis: Diese Passwörter sind nur für Lehrende bestimmt.

Aufgabe Thema Passwort
Aufgabe 1 Type Casting Übung rainbow
Aufgabe 2 Konstanten richtig einsetzen crystal
Aufgabe 3 Würfel-Simulator mit Zufallszahlen thunder
Aufgabe 4 Kombinierte Operatoren galaxy
Aufgabe 5 Zahlenraten-Spiel (BONUS) phoenix
🏠 Zurück zur Startseite