String ke Int di C: atoi, strtol, dan Mengubah Angka Menjadi Teks

Teks dari pengguna, file, dan command line datang sebagai karakter. "42" adalah tiga byte, yaitu '4', '2', '\0', dan tidak ada satu pun yang merupakan angka 42 sampai kamu mengonversinya. C menawarkan dua generasi fungsi konversi: yang lama dan pendek yang tidak bisa melaporkan error, dan yang lebih panjang yang bisa. Halaman ini menunjukkan keduanya dan menjelaskan kenapa program sungguhan memakai set yang kedua.

Keluarga Lama: atoi, atol, atof

Namanya sudah menjelaskan isinya: ASCII ke int, ke long, ke double. Satu argumen, satu hasil.

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

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

Spasi di awal dilewati, tanda opsional dibaca, digit-digitnya diambil, dan semua yang ada sesudahnya diabaikan. Itu praktis sampai input-nya salah:

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

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

Ketiganya mencetak 0. Tidak ada kode kembalian, tidak ada flag, tidak ada cara untuk bertanya "berhasil atau tidak?", dan nilai yang melebihi batas int adalah undefined behavior, bukan error yang dilaporkan. Untuk literal yang ditulis langsung di program mainan, itu masih bisa ditoleransi. Untuk apa pun yang bisa diberikan oleh orang atau file, fungsi ini adalah pabrik bug yang diam-diam.

Alat yang Tepat: strtol

strtol (string to long) melakukan konversi yang sama dengan dua jalur untuk melaporkan apa yang terjadi.

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

endptr diisi dengan karakter pertama yang tidak dibaca fungsi tersebut. base adalah basis bilangan: pakai 10, atau 0 untuk membiarkan prefiks literal itu sendiri yang menentukan (0x untuk heksadesimal, 0 di depan untuk oktal).

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

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

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

    printf("value = %ld\n", value);
    printf("stopped at: \"%s\"\n", end);
    printf("consumed %td characters\n", end - input);
    return 0;
}

Membaca endptr menjawab pertanyaan yang tidak bisa dijawab atoi:

• end == input berarti tidak ada yang dikonversi: teksnya tidak diawali angka.
• *end != '\0' berarti ada isi tambahan di belakang. Apakah itu error atau bukan, kamu yang menentukan: tidak masalah saat mengurai "42 apples", tetapi jadi masalah jika seluruh baris seharusnya berupa angka.

Overflow dilaporkan secara terpisah lewat errno. Pola lengkap yang benar ini layak ditulis sekali lalu dipakai ulang:

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

/* returns 1 on success, 0 on any kind of failure */
int parse_int(const char *text, int *out) {
    char *end;
    errno = 0;

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

    if (end == text) {
        return 0;                 /* no digits at all */
    }
    if (*end != '\0') {
        return 0;                 /* trailing junk */
    }
    if (errno == ERANGE || value < INT_MIN || value > INT_MAX) {
        return 0;                 /* out of range for an int */
    }

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

int main(void) {
    const char *tests[] = {"42", "-7", "hello", "", "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\" -> rejected\n", tests[i]);
        }
    }
    return 0;
}

Tiga detail membuat kode ini benar. errno = 0 sebelum pemanggilan itu penting karena library hanya pernah mengisi errno dan tidak pernah mengosongkannya, sehingga nilai lama dari pemanggilan sebelumnya bisa terbaca sebagai kegagalan pemanggilan ini. strtol mengembalikan long, yang bisa lebih lebar daripada int, jadi pengecekan rentang terhadap INT_MIN/INT_MAX terpisah dari ERANGE. Terakhir, mengembalikan status keberhasilan sambil mengirim nilainya lewat pointer adalah cara fungsi C melaporkan "entah sebuah nilai, entah sebuah kegagalan", karena nilai kembalian tidak bisa melakukan dua tugas sekaligus.

strtoul adalah versi unsigned-nya, dan strtoll/strtoull menangani long long.

Basis Lain

Basis 16 membaca heksadesimal; basis 0 memeriksa prefiksnya dan memutuskan sendiri. Untuk mengecek arti sebuah string di basis lain, tempelkan ke pengonversi basis bilangan.

#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, prefix detected */
    printf("%ld\n", strtol("1011", &end, 2));     /* 11, binary */
    printf("%ld\n", strtol("755", &end, 8));      /* 493, octal */
    return 0;
}

Basis 0 menjadi jebakan dalam satu kasus khusus: desimal yang diawali nol seperti "012" dibaca sebagai oktal dan hasilnya 10. Jika input-mu desimal, tulis 10 secara eksplisit.

Bilangan Pecahan: strtod

strtod punya bentuk yang sama untuk double, dan atof punya kelemahan yang sama dengan 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("not a number\n");
    } else if (errno == ERANGE) {
        printf("out of range\n");
    } else {
        printf("value = %f, stopped at \"%s\"\n", value, end);
    }
    return 0;
}

strtod juga menerima notasi ilmiah ("1.5e3"), float heksadesimal, serta kata "inf" dan "nan". Locale memengaruhi pemisah desimal, dan ini sering mengejutkan orang yang mengurai file yang ditulis di tempat lain. Di locale "C" bawaan, pemisahnya selalu titik.

Angka ke Teks: snprintf

Untuk arah sebaliknya, snprintf adalah jawaban standarnya. Fungsi ini menulis paling banyak sebesar ukuran yang kamu berikan, selalu mengakhiri string, dan mengembalikan panjang yang dibutuhkan hasil lengkapnya.

#include <stdio.h>

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

    int written = snprintf(buf, sizeof buf, "%d", n);
    printf("text: \"%s\" (needed %d chars)\n", buf, written);

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

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

Nilai kembalian itulah pengecekan pemotongannya. Jika nilainya lebih besar dari atau sama dengan ukuran buffer, teksnya tidak muat:

#include <stdio.h>

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

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

    if (needed < 0) {
        printf("encoding error\n");
    } else if ((size_t)needed >= sizeof small) {
        printf("truncated: \"%s\" (needed %d bytes)\n", small, needed + 1);
    } else {
        printf("ok: %s\n", small);
    }
    return 0;
}

Dua hal yang sebaiknya tidak kamu pakai: itoa bukan bagian dari C standar, jadi kode yang memakainya tidak bisa di-compile di semua tempat; dan sprintf adalah snprintf tanpa batas ukuran, artinya fungsi ini akan menulis melewati ujung buffer-mu tanpa protes.

Karakter Tunggal dan '0'

Karakter digit '0' sampai '9' dijamin berurutan, jadi pengurangan biasa sudah cukup untuk mengonversi antara karakter digit dan nilainya.

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

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

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

Hanya digit yang berperilaku seperti ini. Huruf tidak wajib berurutan, jadi c - 'a' tidak portabel untuk aritmetika alfabet. Lindungi pengurangannya dengan isdigit sebelum memercayainya:

#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("digits sum to %d\n", sum);
    return 0;
}

Cast ke unsigned char diperlukan dengan alasan yang sama seperti pada string: fungsi-fungsi <ctype.h> tidak terdefinisi untuk argumen negatif, dan char biasa bisa bersifat signed.

Fungsi Mana yang Dipakai

• Teks dari pengguna, file, atau argv → strtol / strtod dengan pengecekan lengkap.
• Literal yang kamu tulis dan kendalikan sendiri → atoi masih bisa diterima, walau biasa saja.
• Angka ke dalam buffer → snprintf, lalu cek nilai kembaliannya.
• Satu karakter digit → kurangi dengan '0', setelah isdigit.
• Jangan pernah → gets, sprintf, itoa.