Verstehen und anwenden von impliziter und expliziter Typkonvertierung
Arbeiten mit const und #define für unveränderliche Werte
Generieren von Pseudo-Zufallszahlen mit rand() und srand()
Kombinierte Zuweisungen, Inkrement/Dekrement und Operator-Prioritäten
Ziel: Verstehen Sie das Problem der Ganzzahldivision und beheben Sie es mit Type Casting.
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!
4 / 5 = 0 (nicht 0.8!). Verwenden Sie (double) für das Casting.
Erfolgsquote: 80.00%
#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!
Ziel: Arbeiten mit const und #define für mathematische Konstanten.
Erstellen Sie ein Programm, das geometrische Berechnungen durchführt:
const, einmal mit #define)2 * π * rπ * r²(4/3) * π * r³const double PI = 3.14159265; #define MEHRWERTSTEUER 0.19
Radius eingeben: 5 Umfang: 31.42 Fläche: 78.54 Volumen: 523.60
#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.
Ziel: Generieren Sie echte Pseudo-Zufallszahlen und simulieren Sie Würfelwürfe.
Erstellen Sie einen Würfel-Simulator:
srand(time(NULL))#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;
🎲 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%)
#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.
Ziel: Nutzen Sie kombinierte Zuweisungen und Inkrement/Dekrement effizient.
Erstellen Sie ein Punkte-System für ein Spiel:
+= 50: Bonus einsammeln-= 30: Schaden nehmen*= 2: Power-Up (Punkte verdoppeln)/= 2: Bestrafung (Punkte halbieren)++: Kleiner Bonus--: Kleiner Maluspunkte += 50; // punkte = punkte + 50 punkte++; // punkte = punkte + 1
Start: 100 Punkte + Bonus gesammelt: 150 Punkte + Power-Up aktiviert: 300 Punkte - Schaden erhalten: 270 Punkte + Kleiner Bonus: 271 Punkte
#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!
Ziel: Kombinieren Sie alles - Type Casting, Konstanten, Zufallszahlen und Operatoren!
Erstellen Sie ein vollständiges Zahlenraten-Spiel:
const int MAX_VERSUCHE = 7; int geheimzahl = rand() % 100 + 1; // 1 bis 100
🎯 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
#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.
// FALSCH: Integer-Division double x = 5 / 2; // x = 2.0 // RICHTIG: Mit Cast double y = (double)5 / 2; // y = 2.5
const double PI = 3.14159; // Bevorzugt #define MAX 100 // Präprozessor
srand(time(NULL)); // Einmal int zahl = rand() % 100 + 1; // 1 bis 100
x += 5; // x = x + 5 x++; // x = x + 1 x *= 2; // x = x * 2
const und #define kennensrand() und rand()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
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 |