Unit 4 – Variablen und Datentypen

Ömer sagt:

Jetzt wird's richtig spannend! Programme, die nur Text ausgeben, sind langweilig. Heute lernst du, wie du Daten speichern kannst – Zahlen, Kommazahlen, Zeichen. Variablen sind die Grundbausteine jedes Programms. Ohne sie geht gar nichts! 🧮

Lernziele dieser Unit

Was eine Variable ist int, float, char, double Deklarieren & Initialisieren Variablennamen vergeben Werte zuweisen und ausgeben Speichergröße verstehen

📦 Was ist eine Variable?

Eine Variable ist ein benannter Speicherplatz im Arbeitsspeicher (RAM) des Computers. Du gibst diesem Speicherplatz einen Namen, und kannst dann einen Wert darin speichern – und später wieder abrufen oder verändern.

Die Box-Analogie

Stell dir Variablen wie beschriftete Schachteln vor: Die Schachtel ist der Speicherplatz, der Aufkleber ist der Variablenname, und der Inhalt ist der gespeicherte Wert. Du kannst den Inhalt jederzeit austauschen – der Aufkleber (Name) bleibt aber immer gleich.

Speicher-Visualisierung

int alter

4 Bytes belegt (32-Bit Integer)

float pi

4 Bytes belegt (32-Bit Float)

char note

1 Byte belegt (8-Bit Zeichen)

🗂️ Die wichtigsten Datentypen

In C muss jede Variable einen Datentyp haben. Dieser legt fest, welche Art von Wert gespeichert wird und wie viel Speicher dafür reserviert wird.

🔢int – Ganzzahl

Speichert ganze Zahlen ohne Nachkommastellen. Positiv oder negativ.

Bereich: ca. −2,1 Mrd. bis +2,1 Mrd.

4 Bytes %d int alter = 17;

📐float – Kommazahl

Speichert Kommazahlen (Gleitkommazahlen) mit ca. 7 Dezimalstellen Genauigkeit.

Bereich: ca. ±3.4 × 10³⁸

4 Bytes %f float pi = 3.14f;

🔤char – Zeichen

Speichert ein einzelnes Zeichen (Buchstabe, Ziffer, Sonderzeichen). Intern als Zahl (ASCII) gespeichert.

Bereich: −128 bis +127

1 Byte %c char note = 'A';

🎯double – Genauere Kommazahl

Wie float, aber mit doppelter Genauigkeit (ca. 15–17 Dezimalstellen). Für wissenschaftliche Berechnungen.

Bereich: ca. ±1.8 × 10³⁰⁸

8 Bytes %lf double x = 3.14159265;

Datentyp	Speicher	Wertebereich	Format	Beispiel
int	4 Byte	−2.147.483.648 bis +2.147.483.647	`%d`	`int x = 42;`
float	4 Byte	ca. ±3.4 × 10³⁸ (7 Stellen)	`%f`	`float f = 3.14f;`
double	8 Byte	ca. ±1.8 × 10³⁰⁸ (15 Stellen)	`%lf`	`double d = 3.14;`
char	1 Byte	−128 bis +127 (ASCII: 0–127)	`%c`	`char c = 'A';`

✍️ Deklarieren und Initialisieren

Eine Variable wird mit Datentyp + Name deklariert. Beim Initialisieren bekommt sie gleichzeitig einen Startwert:

variablen.c C

#include <stdio.h>

int main() {

    /* --- Deklaration (nur anlegen, noch kein Wert) --- */
    int punkte;

    /* --- Initialisierung (Deklaration + Wert gleichzeitig) --- */
    int    alter     = 17;
    float  groesse   = 1.78f;       // 'f' = float-Literal
    double pi        = 3.14159265;
    char   note      = 'A';          // Einzelzeichen in ' '

    /* --- Wert später zuweisen --- */
    punkte = 95;

    /* --- Ausgabe mit printf und Format-Zeichen --- */
    printf("Alter:   %d Jahre\n",    alter);
    printf("Größe:   %.2f m\n",   groesse);
    printf("Pi:      %.5lf\n",     pi);
    printf("Note:    %c\n",        note);
    printf("Punkte:  %d\n",       punkte);

    return 0;
}

▶ Ausgabe

Alter: 17 Jahre
Größe: 1.78 m
Pi: 3.14159
Note: A
Punkte: 95

🔣 Format-Zeichen in printf

Beim Ausgeben von Variablen mit printf braucht man Format-Zeichen (Platzhalter). Diese sagen printf, welchen Datentyp es ausgeben soll:

Format	Typ	Beispiel-Code	Ausgabe
%d	int (Ganzzahl)	`printf("%d", 42);`	42
%f	float / double	`printf("%f", 3.14f);`	3.140000
%.2f	float, 2 Nachkommastellen	`printf("%.2f", 3.14159f);`	3.14
%c	char (Zeichen)	`printf("%c", 'A');`	A
%s	String (Text)	`printf("%s", "Hallo");`	Hallo
%lf	double (genau)	`printf("%lf", 3.14);`	3.140000

📛 Regeln für Variablennamen

Nicht jeder Name ist als Variablenname erlaubt. C hat klare Regeln:

✅ ERLAUBT

alter mein_name punkte2024 _intern groesse

❌ NICHT ERLAUBT

2punkte ← beginnt mit Zahl mein name ← Leerzeichen int ← ist ein Schlüsselwort mein-name ← Bindestrich größe ← Umlaute

Konvention: snake_case

In C verwendet man üblicherweise snake_case für Variablennamen: alle Buchstaben klein, Wörter mit Unterstrich getrennt. Beispiel: meine_variable, anzahl_schueler, gesamt_punkte.

💡 Praxisbeispiel: Schülerdaten

schueler_daten.c C

#include <stdio.h>

int main() {
    /* Schülerdaten speichern */
    int    alter        = 16;
    float  durchschnitt = 2.3f;
    char   klasse       = 'A';
    int    schul_jahr   = 3;

    printf("========== Schülerprofil ==========\n");
    printf("Klasse:        %d%c\n",    schul_jahr, klasse);
    printf("Alter:         %d Jahre\n", alter);
    printf("Notenschnitt:  %.1f\n",    durchschnitt);
    printf("===================================\n");

    return 0;
}

▶ Ausgabe

========== Schülerprofil ==========
Klasse: 3A
Alter: 16 Jahre
Notenschnitt: 2.3
===================================

✏️ Übungen

Übung 1

Datentypen zuordnen

Welcher Datentyp ist am besten geeignet? Schreibe int, float, char oder double:

Die Anzahl der Schüler in einer Klasse → ___________
Die Körpertemperatur (z.B. 36.8) → ___________
Ein einzelner Buchstabe (A, B, C ...) → ___________
Das Jahr (z.B. 2025) → ___________
Der Wert von Pi mit 14 Nachkommastellen → ___________
Die Note (1, 2, 3, 4 oder 5) → ___________

Übung 2

Variablen deklarieren

Schreibe für jede der folgenden Aufgaben die korrekte C-Deklaration mit Initialisierung:

Eine Ganzzahl namens punkte mit dem Wert 100:

Eine Kommazahl namens temperatur mit dem Wert 36.6:

Ein Zeichen namens buchstabe mit dem Buchstaben 'Z':

Eine double-Zahl namens kreiszahl mit dem Wert 3.14159265:

Denke an das 'f' bei float-Werten: float x = 3.14f;

Übung 3

Format-Zeichen ergänzen

Fülle die fehlenden Format-Zeichen in den printf-Aufrufen aus:

C – LÜCKEN FÜLLEN

int    a = 42;
float  b = 9.81f;
char   c = 'X';

printf("a = ___\n", a);      // Ganzzahl
printf("b = ___\n", b);      // Kommazahl
printf("c = ___\n", c);      // Zeichen

Format-Zeichen: %d für int · %f für float · %c für char

Übung 4 – Programm schreiben

Eigenes Profil

Schreibe ein C-Programm, das dein Profil speichert und ausgibt: Vorname (als einzelnen char-Anfangsbuchstaben), Alter (int), Notenschnitt (float) und Klasse (char). Verwende sinnvolle Variablennamen.

#include <stdio.h> int main() { /* Hier dein Code */ return 0; }

Erwartete Ausgabe (Beispiel):

Übung 5 – Experiment

Was passiert bei falschem Format-Zeichen?

Führe diesen Code zuerst unverändert aus und notiere die Ausgabe. Korrigiere dann die Format-Zeichen und führe ihn erneut aus – erkläre den Unterschied:

#include <stdio.h> int main() { int alter = 17; float note = 2.5f; char klasse = 'A'; /* FEHLER: falsche Format-Zeichen absichtlich eingebaut */ printf("Alter: %f\n", alter); /* int mit %f ausgeben */ printf("Note: %d\n", note); /* float mit %d ausgeben */ printf("Klasse: %d\n", klasse); /* char mit %d ausgeben */ return 0; }

💡 Beobachte genau: Was gibt der Compiler aus, wenn Typ und Format-Zeichen nicht übereinstimmen? Das erklärt, warum präzise Format-Zeichen so wichtig sind!

Übung 6 – Bonus

Temperatur-Konverter

Schreibe ein Programm, das eine Temperatur in Celsius speichert und sie in Fahrenheit umrechnet. Formel: F = C * 9.0/5.0 + 32

#include <stdio.h> int main() { float celsius = 100.0f; float fahrenheit = /* Formel hier */; printf("%.1f Grad Celsius = %.1f Grad Fahrenheit\n", celsius, fahrenheit); return 0; }

Teste mit bekannten Werten: 0°C = 32°F, 100°C = 212°F, 37°C ≈ 98.6°F