C Academy · Lektion

Fallstricke bei Konvertierungen

Überlauf und Abschneiden

Fallstricke bei Konvertierungen ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Konvertierungen können problematisch sein

Stille Konvertierungen sind praktisch, können aber zu Überläufen, Abschneiden und Überraschungen beim Vorzeichen führen. Diese Lektion behandelt die Fallen.

#include <stdio.h>
int main(void) {
    printf("Beware silent conversions\n");
    return 0;
}

Ganzzahlüberlauf

Wenn Sie einen Wert zuweisen, der zu groß für den Zieltyp ist, läuft die Zahl über oder Daten gehen verloren.

#include <stdio.h>
#include <limits.h>
int main(void) {
    int max = INT_MAX;
    printf("INT_MAX = %d\n", max);
    return 0;
}

Abschneiden bei Verkleinerung

Wenn Sie einen großen Wert in einem kleineren Typ speichern, bleiben nur die niederwertigen Bits erhalten, wodurch die Zahl unbemerkt beschädigt wird.

#include <stdio.h>
int main(void) {
    int big = 300;
    unsigned char small = (unsigned char)big;
    printf("small = %d\n", small);
    return 0;
}

Gemischte signed- und unsigned-Werte

Beim Mischen von signed und unsigned wird der signed-Wert in unsigned konvertiert, wodurch negative Werte zu riesigen positiven Zahlen werden.

#include <stdio.h>
int main(void) {
    int a = -1;
    unsigned int b = 1;
    if (a > b)
        printf("surprise: -1 > 1 as unsigned\n");
    return 0;
}

Falle bei Schleifenzählern

Ein unsigned-Schleifenzähler, der unter null fällt, läuft auf einen riesigen Wert über und verursacht eine Endlosschleife. Verwenden Sie beim Herunterzählen signed-Zähler.

#include <stdio.h>
int main(void) {
    for (int i = 3; i >= 0; i--)
        printf("%d ", i);
    printf("\n");
    return 0;
}

Verlust bei float zu int

Bei der Konvertierung von float zu int geht der Nachkommateil verloren. Überschreitet der Wert den Wertebereich von int, ist das Ergebnis undefiniert.

#include <stdio.h>
int main(void) {
    double d = 3.99;
    int n = (int)d;
    printf("n = %d\n", n);
    return 0;
}

Genauigkeitsverlust von double zu float

Wenn Sie einen double mit hoher Genauigkeit in einem float speichern, gehen Ziffern verloren. Dieser Verlust kann sich bei langen Berechnungen aufsummieren.

#include <stdio.h>
int main(void) {
    double d = 1.123456789012345;
    float f = (float)d;
    printf("%.7f\n", f);
    return 0;
}

Überraschungen beim Vorzeichen von char

Ob char vorzeichenbehaftet ist, ist implementationsdefiniert. Verwenden Sie unsigned char für Bytewerte, um negative Ergebnisse zu vermeiden.

#include <stdio.h>
int main(void) {
    unsigned char b = 200;
    printf("b = %d\n", b);
    return 0;
}

Erst dividieren, dann konvertieren

Nach einer Ganzzahldivision kann ein anschließender Cast den verlorenen Nachkommateil nicht wiederherstellen. Casten Sie vor der Division.

#include <stdio.h>
int main(void) {
    int a = 7, b = 2;
    double wrong = (double)(a / b);
    double right = (double)a / b;
    printf("%.1f vs %.1f\n", wrong, right);
    return 0;
}

Wertebereiche vergleichen

Verwenden Sie die Konstanten aus limits.h, um den Wertebereich eines Typs zu bestimmen, bevor Sie davon ausgehen, dass ein Wert hineinpasst.

#include <stdio.h>
#include <limits.h>
int main(void) {
    printf("char range: %d to %d\n", CHAR_MIN, CHAR_MAX);
    return 0;
}

Defensive Konvertierungen

Überprüfen Sie vor einer Verkleinerung die Wertebereiche, bevorzugen Sie im Zweifel größere Typen und machen Sie Casts explizit, damit die Absicht klar ist.

#include <stdio.h>
int main(void) {
    long value = 200;
    if (value >= 0 && value <= 255)
        printf("fits in a byte: %ld\n", value);
    return 0;
}

Kurzer Test

Testen Sie Ihr Verständnis der Fallen bei Konvertierungen.

Rückblick: Fallen bei Konvertierungen

Sie haben die Gefahren stiller Konvertierungen kennengelernt.

Eine Verkleinerung kann zu Überläufen oder Abschneiden führen
Das Mischen von signed und unsigned kann Vergleiche umkehren
Unsigned-Zähler laufen unter null über
Casten Sie vor der Division, damit Nachkommateile erhalten bleiben
Überprüfen Sie Wertebereiche und machen Sie Casts explizit

Häufig gestellte Fragen

Ist die Lektion „Fallstricke bei Konvertierungen“ kostenlos?

Ja — der vollständige Text von „Fallstricke bei Konvertierungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Fallstricke bei Konvertierungen“?

Überlauf und Abschneiden Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Fallstricke bei Konvertierungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C Academy