Ausführbare C-Docs: Zeichenkettenumwandlung

Q: Wie wandelt man in C eine Zeichenkette in ein int um?

strtol(text, &end, 10) ist die richtige Antwort: Es liefert den Wert, setzt end auf das erste nicht verbrauchte Zeichen und meldet einen Überlauf über errno. atoi(text) ist kürzer, liefert aber 0 sowohl für "0" als auch für "hallo", ohne dass man beides unterscheiden könnte.

Q: Was ist an atoi in C falsch?

Es kann keinen Fehlschlag melden. atoi("abc") liefert 0, was von einer echten Null nicht zu unterscheiden ist, und ein Überlauf ist undefiniertes Verhalten statt eines gemeldeten Fehlers. Nimm strtol, wann immer der Text von einem Benutzer, einer Datei oder einem Kommandozeilenargument kam.

Q: Wie wandle ich in C ein int in eine Zeichenkette um?

snprintf(buf, sizeof buf, "%d", n). Es ist Standard, durch die Puffergröße begrenzt und liefert die Anzahl der Zeichen, die das vollständige Ergebnis gebraucht hätte - ein Rückgabewert ab sizeof buf sagt dir also, dass der Text abgeschnitten wurde. itoa ist kein Standard-C.

Q: Wie mache ich in C aus dem Zeichen '7' die Zahl 7?

Zieh '0' ab: int digit = c - '0';. Die Ziffernzeichen liegen in jedem C-Zeichensatz aufeinanderfolgend, die Subtraktion ergibt also 0 bis 9. Sichere es zuvor mit isdigit((unsigned char)c) ab, denn für alles andere ist die Rechnung bedeutungslos.

Text kommt von Benutzern, Dateien und der Kommandozeile als Zeichen an. "42" sind drei Bytes - '4', '2', '\0' - und nichts daran ist die Zahl 42, bis du es umwandelst. C bietet zwei Generationen von Umwandlungsfunktionen: die kurzen, alten, die keine Fehler melden können, und die längeren, die es können. Diese Seite zeigt beide und erklärt, warum echte Programme den zweiten Satz benutzen.

Die alte Familie: atoi, atol, atof

Sie lesen sich wie ihre Namen: ASCII nach int, nach long, nach double. Ein Argument, ein Ergebnis.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    printf("%d\n", atoi("42"));
    printf("%d\n", atoi("  -17 Rest dahinter"));
    printf("%f\n", atof("3.14"));
    return 0;
}

Führender Leerraum wird übersprungen, ein optionales Vorzeichen gelesen, Ziffern verbraucht, und alles danach ignoriert. Das ist bequem, bis die Eingabe falsch ist:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    printf("atoi(\"0\")     = %d\n", atoi("0"));
    printf("atoi(\"hallo\") = %d\n", atoi("hallo"));
    printf("atoi(\"\")      = %d\n", atoi(""));
    return 0;
}

Alle drei geben 0 aus. Es gibt keinen Rückgabecode, kein Flag, keine Möglichkeit zu fragen „hat das geklappt?" - und ein Wert, der int überschreitet, ist undefiniertes Verhalten statt eines gemeldeten Fehlers. Für ein fest eingetragenes Literal in einem Spielzeugprogramm ist das erträglich. Für alles, was eine Person oder eine Datei liefern kann, ist es ein stiller Fehlererzeuger.

Das richtige Werkzeug: strtol

strtol (string to long) ist dieselbe Umwandlung mit zwei Kanälen, um zu melden, was geschah.

long strtol(const char *text, char **endptr, int base);

endptr wird auf das erste Zeichen gesetzt, das die Funktion nicht verbraucht hat. base ist die Zahlenbasis - nimm 10, oder 0, um das Präfix des Literals entscheiden zu lassen (0x für hexadezimal, führende 0 für oktal).

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    const char *input = "42 Aepfel";
    char *end;

    long value = strtol(input, &end, 10);

    printf("Wert = %ld\n", value);
    printf("gestoppt bei: \"%s\"\n", end);
    printf("%td Zeichen verbraucht\n", end - input);
    return 0;
}

endptr zu lesen beantwortet die Fragen, die atoi nicht kann:

end == input bedeutet, dass nichts umgewandelt wurde - der Text begann nicht mit einer Zahl.
*end != '\0' bedeutet, dass dahinter noch Inhalt stand. Ob das ein Fehler ist, entscheidest du: Beim Auswerten von "42 Aepfel" ist es in Ordnung und ein Problem, wenn die ganze Zeile eine Zahl hätte sein sollen.

Ein Überlauf wird separat über errno gemeldet. Das vollständige, korrekte Idiom lohnt sich einmal zu schreiben und wiederzuverwenden:

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <limits.h>

/* liefert 1 bei Erfolg, 0 bei jeder Art von Fehlschlag */
int parse_int(const char *text, int *out) {
    char *end;
    errno = 0;

    long value = strtol(text, &end, 10);

    if (end == text) {
        return 0;                 /* ueberhaupt keine Ziffern */
    }
    if (*end != '\0') {
        return 0;                 /* Rest dahinter */
    }
    if (errno == ERANGE || value < INT_MIN || value > INT_MAX) {
        return 0;                 /* ausserhalb des int-Bereichs */
    }

    *out = (int)value;
    return 1;
}

int main(void) {
    const char *tests[] = {"42", "-7", "hallo", "", "9999999999", "12abc"};
    int n = (int)(sizeof tests / sizeof tests[0]);

    for (int i = 0; i < n; i++) {
        int value;
        if (parse_int(tests[i], &value)) {
            printf("\"%s\" -> %d\n", tests[i], value);
        } else {
            printf("\"%s\" -> abgelehnt\n", tests[i]);
        }
    }
    return 0;
}

Drei Einzelheiten machen das korrekt. errno = 0 vor dem Aufruf zählt, weil die Bibliothek errno nur je setzt; sie löscht es nie, ein alter Wert aus einem früheren Aufruf würde also als Fehlschlag dieses Aufrufs gelesen. strtol liefert long, das breiter als int sein kann, die Bereichsprüfung gegen INT_MIN/INT_MAX ist also von ERANGE getrennt. Und den Erfolg als Status zu liefern, während der Wert über einen Zeiger übergeben wird, ist die Art, wie C-Funktionen „entweder ein Wert oder ein Fehlschlag" melden - der Rückgabewert kann nicht beide Aufgaben erfüllen.

strtoul ist das vorzeichenlose Gegenstück, und strtoll/strtoull behandeln long long.

Andere Basen

Basis 16 liest hexadezimal; Basis 0 prüft das Präfix und entscheidet selbst.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    char *end;

    printf("%ld\n", strtol("ff", &end, 16));      /* 255 */
    printf("%ld\n", strtol("0x1A", &end, 0));     /* 26, Praefix erkannt */
    printf("%ld\n", strtol("1011", &end, 2));     /* 11, binaer */
    printf("%ld\n", strtol("755", &end, 8));      /* 493, oktal */
    return 0;
}

Basis 0 ist in einem bestimmten Fall eine Falle: Eine mit Nullen aufgefüllte Dezimalzahl wie "012" wird als oktal gelesen und kommt als 10 heraus. Ist deine Eingabe dezimal, sag ausdrücklich 10.

Gleitkommazahlen: strtod

strtod hat dieselbe Form für double, und atof hat denselben Makel wie atoi.

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(void) {
    const char *text = "3.14159 Rest";
    char *end;
    errno = 0;

    double value = strtod(text, &end);

    if (end == text) {
        printf("keine Zahl\n");
    } else if (errno == ERANGE) {
        printf("ausserhalb des Bereichs\n");
    } else {
        printf("Wert = %f, gestoppt bei \"%s\"\n", value, end);
    }
    return 0;
}

strtod akzeptiert auch wissenschaftliche Notation ("1.5e3"), hexadezimale Gleitkommazahlen und die Wörter "inf" und "nan". Die Locale beeinflusst das Dezimaltrennzeichen, was Leute überrascht, die anderswo geschriebene Dateien auswerten - in der Standard-Locale „C" ist das Trennzeichen immer ein Punkt.

Zahlen zu Text: snprintf

In die andere Richtung ist snprintf die Standardantwort. Es schreibt höchstens die Größe, die du ihm gibst, terminiert immer und liefert die Länge, die das vollständige Ergebnis gebraucht hätte.

#include <stdio.h>

int main(void) {
    char buf[32];
    int n = 4095;

    int written = snprintf(buf, sizeof buf, "%d", n);
    printf("Text: \"%s\" (brauchte %d Zeichen)\n", buf, written);

    snprintf(buf, sizeof buf, "%05d", n);
    printf("aufgefuellt: %s\n", buf);

    snprintf(buf, sizeof buf, "%x / %o / %.2f", n, n, n / 1000.0);
    printf("gemischt:    %s\n", buf);
    return 0;
}

Der Rückgabewert ist die Abschneideprüfung. Ist er größer oder gleich der Puffergröße, passte der Text nicht:

#include <stdio.h>

int main(void) {
    char small[8];

    int needed = snprintf(small, sizeof small, "Wert=%d", 1234567);

    if (needed < 0) {
        printf("Kodierungsfehler\n");
    } else if ((size_t)needed >= sizeof small) {
        printf("abgeschnitten: \"%s\" (brauchte %d Bytes)\n", small, needed + 1);
    } else {
        printf("ok: %s\n", small);
    }
    return 0;
}

Zwei Dinge, zu denen man nicht greifen sollte: itoa gehört nicht zum Standard-C, Code, der es benutzt, kompiliert also nicht überall; und sprintf ist snprintf ohne die Größenbegrenzung, was bedeutet, dass es kommentarlos über das Ende deines Puffers hinausschreibt.

Einzelne Zeichen und '0'

Die Ziffernzeichen '0' bis '9' liegen garantiert aufeinanderfolgend, schlichte Subtraktion wandelt also zwischen einem Ziffernzeichen und seinem Wert um.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    char c = '7';
    int digit = c - '0';
    printf("Zeichen '%c' -> int %d\n", c, digit);

    int value = 3;
    char back = (char)(value + '0');
    printf("int %d -> Zeichen '%c'\n", value, back);
    return 0;
}

Nur Ziffern verhalten sich so - Buchstaben müssen nicht aufeinanderfolgen, c - 'a' ist für Alphabetarithmetik also nicht portabel. Sichere die Subtraktion mit isdigit ab, bevor du ihr traust:

#include <stdio.h>
#include <ctype.h>

int main(void) {
    char text[] = "a1b2c3";
    int sum = 0;

    for (int i = 0; text[i] != '\0'; i++) {
        if (isdigit((unsigned char)text[i])) {
            sum += text[i] - '0';
        }
    }

    printf("Ziffernsumme ist %d\n", sum);
    return 0;
}

Der Cast nach unsigned char ist aus demselben Grund nötig wie bei Zeichenketten: Die Funktionen aus <ctype.h> sind für negative Argumente undefiniert, und ein schlichtes char kann vorzeichenbehaftet sein.

Welche Funktion man nimmt

Text von einem Benutzer, einer Datei oder aus argv → strtol / strtod mit der vollen Prüfung.
Ein selbst geschriebenes Literal, das du kontrollierst → atoi ist akzeptabel, wenn auch unspektakulär.
Zahl in einen Puffer → snprintf, und prüfe den Rückgabewert.
Ein einzelnes Ziffernzeichen → '0' abziehen, nach isdigit.
Niemals → gets, sprintf, itoa.

Häufig gestellte Fragen

Wie wandelt man in C eine Zeichenkette in ein int um?

strtol(text, &end, 10) ist die richtige Antwort: Es liefert den Wert, setzt end auf das erste nicht verbrauchte Zeichen und meldet einen Überlauf über errno. atoi(text) ist kürzer, liefert aber 0 sowohl für "0" als auch für "hallo", ohne dass man beides unterscheiden könnte.

Was ist an atoi in C falsch?

Es kann keinen Fehlschlag melden. atoi("abc") liefert 0, was von einer echten Null nicht zu unterscheiden ist, und ein Überlauf ist undefiniertes Verhalten statt eines gemeldeten Fehlers. Nimm strtol, wann immer der Text von einem Benutzer, einer Datei oder einem Kommandozeilenargument kam.

Wie wandle ich in C ein int in eine Zeichenkette um?

snprintf(buf, sizeof buf, "%d", n). Es ist Standard, durch die Puffergröße begrenzt und liefert die Anzahl der Zeichen, die das vollständige Ergebnis gebraucht hätte - ein Rückgabewert ab sizeof buf sagt dir also, dass der Text abgeschnitten wurde. itoa ist kein Standard-C.

Wie mache ich in C aus dem Zeichen '7' die Zahl 7?

Zieh '0' ab: int digit = c - '0';. Die Ziffernzeichen liegen in jedem C-Zeichensatz aufeinanderfolgend, die Subtraktion ergibt also 0 bis 9. Sichere es zuvor mit isdigit((unsigned char)c) ab, denn für alles andere ist die Rechnung bedeutungslos.

Verwandte Konzepte