🔄
Type Casting, Konstanten
und Operatoren
Fortgeschrittene Algorithmen und Programmierung
Wintersemester 2025/26
Prof. Dr. Alexandra Mikityuk
📍 Raum C308 | 🏫 HTW Berlin
Drücken Sie → oder Leertaste zum Starten
Teil 1: Konvertierung & Konstanten
- Type Casting (Cast-Operator)
- Implizite vs. Explizite Konvertierung
- Konstanten mit const
- Präprozessor #define
Teil 2: Zufallszahlen & Operatoren
- Zufallszahlen generieren
- Kombinierte Zuweisungen
- Inkrement/Dekrement
- Operator-Prioritäten
Type Casting = Typ-Umwandlung
Manchmal müssen wir einen Wert von einem Datentyp in einen anderen umwandeln.
💡 Alltags-Analogie:
Sie haben Wasser in einer Flasche (Container-Typ 1) und möchten es in ein Glas (Container-Typ 2) umfüllen.
Das Wasser bleibt dasselbe, aber der Container ändert sich!
Implizit (automatisch)
C macht es von selbst
Explizit (manuell)
Wir sagen C, was zu tun ist
C konvertiert automatisch, wenn ein kleinerer Typ einem größeren zugewiesen wird:
int ganzzahl = 42;
double kommazahl;
kommazahl = ganzzahl;
printf("%.2lf\n", kommazahl);
int a = 5;
double b = 2.0;
double ergebnis = a + b;
printf("%.2lf\n", ergebnis);
💡 Regel: Kleinerer Typ → Größerer Typ funktioniert automatisch und sicher!
Wenn wir von größer nach kleiner konvertieren wollen, müssen wir es explizit sagen:
double kommazahl = 3.14159;
int ganzzahl;
ganzzahl = (int)kommazahl;
printf("%d\n", ganzzahl);
int zaehler = 5;
int nenner = 2;
double ergebnis1 = zaehler / nenner;
double ergebnis2 = (double)zaehler / nenner;
printf("Ohne Cast: %.2lf\n", ergebnis1);
printf("Mit Cast: %.2lf\n", ergebnis2);
#include <stdio.h>
int main() {
int note1 = 85, note2 = 90, note3 = 78;
int summe = note1 + note2 + note3;
double durchschnitt1 = summe / 3;
printf("Falsch: %.2lf\n", durchschnitt1);
double durchschnitt2 = (double)summe / 3;
printf("Richtig: %.2lf\n", durchschnitt2);
return 0;
}
⚠️ Achtung: Bei Integer-Division werden Nachkommastellen IMMER abgeschnitten,
auch wenn das Ergebnis in eine double-Variable gespeichert wird!
Was ist das Ergebnis von: int x = 7 / 2;
A) 3.5
B) 3
C) 4
D) Compiler-Fehler
💡 Tipp: Beide Zahlen sind Integer!
Warum Konstanten?
- Sicherheit: Wert kann nicht versehentlich geändert werden
- Lesbarkeit: Namen statt "magische Zahlen"
- Wartbarkeit: Änderung nur an einer Stelle nötig
- Performance: Compiler kann optimieren
Beispiel: Die Zahl Pi (3.14159...) ändert sich nie!
Besser als Konstante definieren statt überall 3.14159 einzutippen.
Das const Schlüsselwort macht eine Variable unveränderlich:
const double PI = 3.14159265;
const int MAX_STUDENTEN = 100;
const double MEHRWERTSTEUER = 0.19;
double radius = 5.0;
double umfang = 2 * PI * radius;
printf("Umfang: %.2lf\n", umfang);
💡 Convention: Konstanten-Namen werden traditionell in GROSSBUCHSTABEN geschrieben!
#define ist eine Präprozessor-Direktive (vor dem Kompilieren):
#include <stdio.h>
#define PI 3.14159265
#define MAX_STUDENTEN 100
#define KURS_NAME "Algorithmen"
int main() {
double radius = 5.0;
double flaeche = PI * radius * radius;
printf("Kurs: %s\n", KURS_NAME);
printf("Fläche: %.2lf\n", flaeche);
return 0;
}
⚠️ Beachten: #define verwendet KEIN = und KEIN ;!
Der Präprozessor ersetzt einfach alle Vorkommen vor dem Kompilieren.
| Feature |
const |
#define |
| Typ-Sicherheit |
✅ Hat einen Datentyp |
❌ Nur Text-Ersetzung |
| Debugging |
✅ Einfacher zu debuggen |
❌ Schwieriger |
| Speicher |
⚠️ Belegt Speicher |
✅ Kein Speicher |
| Gültigkeitsbereich |
✅ Respektiert Scope |
⚠️ Global überall |
| Empfehlung |
✅ Bevorzugen! |
⚠️ Nur wenn nötig |
💡 Moderne C-Programmierung: Verwenden Sie const
wann immer möglich. #define ist ein Relikt aus alten C-Zeiten.
Welche Deklaration ist korrekt für eine Konstante mit #define?
A) #define PI = 3.14;
B) #define PI 3.14
C) const #define PI 3.14;
D) #define const PI = 3.14;
Warum Zufallszahlen?
- Spiele: Würfel werfen, Karten mischen
- Simulation: Zufällige Ereignisse modellieren
- Kryptographie: Sichere Passwörter, Schlüssel
- Testing: Zufällige Testdaten generieren
💡 Wichtig: Computer erzeugen Pseudo-Zufallszahlen -
sie sehen zufällig aus, folgen aber einem deterministischen Algorithmus.
rand() gibt eine Zufallszahl zwischen 0 und RAND_MAX zurück:
#include <stdio.h>
#include <stdlib.h>
int main() {
int zufallszahl = rand();
printf("Zufallszahl: %d\n", zufallszahl);
printf("RAND_MAX: %d\n", RAND_MAX);
return 0;
}
⚠️ Problem: Ohne weitere Schritte gibt rand() bei jedem Programmlauf
die GLEICHEN "Zufallszahlen" zurück!
srand() setzt den "Seed" (Startwert) für den Zufallsgenerator:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
srand(time(NULL));
printf("Zufallszahl 1: %d\n", rand());
printf("Zufallszahl 2: %d\n", rand());
printf("Zufallszahl 3: %d\n", rand());
return 0;
}
💡 Regel: Rufen Sie srand(time(NULL)) EINMAL am Anfang
von main() auf, dann können Sie rand() beliebig oft verwenden!
Meistens brauchen wir Zufallszahlen in einem bestimmten Bereich (z.B. Würfel: 1-6):
int wuerfel = rand() % 6 + 1;
int prozent = rand() % 100;
int bereich = rand() % 41 + 10;
Erklärung: rand() % 6 + 1
• rand() % 6 ergibt 0, 1, 2, 3, 4, oder 5
• + 1 verschiebt zu 1, 2, 3, 4, 5, oder 6
• Perfekt für einen Würfel!
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
srand(time(NULL));
printf("Würfel-Simulator\n");
printf("================\n\n");
for (int i = 1; i <= 5; i++) {
int wurf = rand() % 6 + 1;
printf("Wurf %d: %d\n", i, wurf);
}
return 0;
}
Mögliche Ausgabe:
Würfel-Simulator
================
Wurf 1: 4
Wurf 2: 2
Wurf 3: 6
Wurf 4: 1
Wurf 5: 5
Welche Formel erzeugt eine Zufallszahl zwischen 1 und 10?
A) rand() % 10
B) rand() % 10 + 1
C) rand() % 11
D) rand() / 10 + 1
Abkürzungen für häufige Operationen:
| Operator |
Beispiel |
Entspricht |
Beschreibung |
| += |
x += 5 |
x = x + 5 |
Addition |
| -= |
x -= 3 |
x = x - 3 |
Subtraktion |
| *= |
x *= 2 |
x = x * 2 |
Multiplikation |
| /= |
x /= 4 |
x = x / 4 |
Division |
| %= |
x %= 3 |
x = x % 3 |
Modulo (Rest) |
#include <stdio.h>
int main() {
int punkte = 100;
printf("Start: %d Punkte\n", punkte);
punkte += 50;
printf("Nach Bonus: %d\n", punkte);
punkte -= 30;
printf("Nach Strafe: %d\n", punkte);
punkte *= 2;
printf("Verdoppelt: %d\n", punkte);
punkte /= 4;
printf("Geviertelt: %d\n", punkte);
return 0;
}
Ausgabe:
Start: 100 Punkte
Nach Bonus: 150
Nach Strafe: 120
Verdoppelt: 240
Geviertelt: 60
Spezielle Operatoren zum Erhöhen/Verringern um 1:
| Operator |
Beispiel |
Entspricht |
Wann verwenden? |
| ++ (Inkrement) |
x++ |
x = x + 1 |
Zähler erhöhen |
| -- (Dekrement) |
x-- |
x = x - 1 |
Zähler verringern |
int zaehler = 0;
zaehler++;
zaehler++;
zaehler++;
zaehler--;
printf("Zaehler: %d\n", zaehler);
Postfix (x++)
Erst verwenden, dann erhöhen
int x = 5;
int y = x++;
printf("y: %d\n", y);
printf("x: %d\n", x);
Prefix (++x)
Erst erhöhen, dann verwenden
int x = 5;
int y = ++x;
printf("y: %d\n", y);
printf("x: %d\n", x);
💡 Praxis-Tipp: In den meisten Fällen (z.B. Schleifen) macht der Unterschied nichts aus.
Verwenden Sie das, was lesbarer ist!
In welcher Reihenfolge werden Operationen ausgeführt?
Wie in der Mathematik: Punkt vor Strich!
int x = 5 + 3 * 2;
printf("%d\n", x);
⚠️ Regel: Multiplikation und Division haben höhere Priorität als Addition und Subtraktion!
| Priorität |
Operator |
Beschreibung |
Assoziativität |
| 1 (höchste) |
() [] . |
Klammern, Arrays, Zugriff |
→ Links nach rechts |
| 2 |
++ -- ! (type) |
Unäre Operatoren, Cast |
← Rechts nach links |
| 3 |
* / % |
Multiplikation, Division, Modulo |
→ Links nach rechts |
| 4 |
+ - |
Addition, Subtraktion |
→ Links nach rechts |
| 5 |
< <= > >= |
Vergleich |
→ Links nach rechts |
| 6 |
== != |
Gleichheit/Ungleichheit |
→ Links nach rechts |
| 7 (niedrigste) |
= += -= *= /= |
Zuweisung |
← Rechts nach links |
int a = 10, b = 5, c = 2;
int x = a + b * c;
int y = (a + b) * c;
int z = a * b + c / 2;
int w = a++ + ++b;
printf("x=%d, y=%d, z=%d, w=%d\n", x, y, z, w);
💡 Best Practice: Im Zweifelsfall Klammern verwenden!
Code ist lesbar > kurz.
Was ist das Ergebnis von: int x = 10 + 5 * 2;
A) 30
B) 20
C) 25
D) 15
💡 Tipp: Punkt vor Strich!
Was haben wir gelernt?
- ✅ Type Casting - Explizit mit (type)
- ✅ const für typsichere Konstanten
- ✅ #define für Präprozessor-Konstanten
- ✅ rand() und srand() für Zufallszahlen
- ✅ +=, -=, *=, /= kombinierte Operatoren
- ✅ ++, -- Inkrement/Dekrement
- ✅ Prefix vs. Postfix
- ✅ Operator-Prioritäten beachten!
🎯 Praxis-Tipp:
Üben Sie diese Konzepte mit kleinen Programmen - sie sind fundamental für alle weiteren Themen!
Fragen? Weiter üben!
Prof. Dr. Alexandra Mikityuk
Raum: C308
Sprechstunde: Nach Vereinbarung
Nächste Vorlesung:
Funktionen und Pointer!
💻 Übungsaufgabe:
Schreiben Sie ein Programm, das Zufallszahlen generiert und Berechnungen damit durchführt!