Fungsi String di C: strlen, strcpy, strcat, strcmp, dan Lainnya

Setiap fungsi di <string.h> adalah perulangan kecil atas array char yang berhenti di null terminator. Begitu itu jelas, library ini tidak lagi tampak seperti daftar nama yang samar, melainkan beberapa perulangan yang sebenarnya bisa kamu tulis sendiri. Halaman ini membahas fungsi-fungsi yang menangani hampir semua pekerjaan nyata, beserta aturan ukuran yang mencegahnya menulis melewati ujung buffer-mu.

Semua yang ada di sini butuh satu include:

#include <string.h>

strlen: Berapa Banyak Karakter

strlen menghitung byte sampai terminator, tanpa menghitung terminatornya. Hasilnya bertipe size_t, jadi cetak dengan %zu.

#include <stdio.h>
#include <string.h>

int main(void) {
    char word[32] = "banana";

    printf("strlen = %zu\n", strlen(word));
    printf("sizeof = %zu\n", sizeof word);
    return 0;
}

strlen bernilai 6; sizeof bernilai 32. Yang pertama adalah teksnya, yang kedua adalah penyimpanannya. Lihat halaman string untuk tahu kenapa perbedaan itu sangat penting.

strlen menelusuri seluruh string di setiap pemanggilan, jadi jangan menaruhnya di kondisi perulangan untuk string yang sama dan tidak berubah:

/* re-counts the whole string on every iteration */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* count once */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++) { ... }

strcpy dan strncpy: Menyalin

strcpy(dst, src) menyalin karakter-karakternya beserta terminator. Fungsi ini tidak tahu seberapa besar dst, jadi pemanggil harus menjamin dst muat setidaknya strlen(src) + 1 byte.

#include <stdio.h>
#include <string.h>

int main(void) {
    char src[] = "portable";
    char dst[16];

    strcpy(dst, src);
    printf("%s\n", dst);

    /* the sizing rule, checked explicitly */
    if (strlen(src) + 1 <= sizeof dst) {
        printf("fits with %zu bytes to spare\n", sizeof dst - strlen(src) - 1);
    }
    return 0;
}

strncpy menerima jumlah maksimum, tetapi punya jebakan terkenal: jika sumbernya setidaknya n byte, fungsi ini menyalin tepat n karakter dan tanpa terminator. Selalu tambahkan terminatornya sendiri:

#include <stdio.h>
#include <string.h>

int main(void) {
    char src[] = "a very long project name";
    char dst[10];

    strncpy(dst, src, sizeof dst - 1);
    dst[sizeof dst - 1] = '\0';        /* required, not optional */

    printf("[%s]\n", dst);
    return 0;
}

sizeof dst - 1 ditambah terminator eksplisit adalah pola yang perlu kamu hafalkan. (strncpy juga mengisi sumber yang pendek dengan nol sampai n byte, yang membuang waktu untuk buffer besar. Fungsi ini dirancang untuk record dengan lebar tetap, bukan untuk keamanan.)

strcat dan strncat: Menggabungkan

strcat(dst, src) menambahkan src ke akhir isi dst yang sudah ada. Tujuannya harus muat kedua string ditambah satu terminator, dan harus sudah berisi string yang valid. Menambahkan ke memori yang belum diinisialisasi adalah undefined behavior.

#include <stdio.h>
#include <string.h>

int main(void) {
    char path[64] = "/home/ada";

    strcat(path, "/");
    strcat(path, "notes.txt");

    printf("%s\n", path);
    printf("used %zu of %zu bytes\n", strlen(path) + 1, sizeof path);
    return 0;
}

Perhatikan char path[64] = "/home/ada";, bukan char path[64];. Inisialisasi itulah yang membuatnya menjadi string valid untuk strcat pertama.

strncat(dst, src, n) menambahkan paling banyak n karakter dan selalu menambahkan terminator, jadi n adalah sisa ruang, bukan total ukuran buffer:

strncat(dst, src, sizeof dst - strlen(dst) - 1);

Pemanggilan strcat berulang kali selalu memindai ulang tujuannya untuk mencari ujungnya. Menyusun string panjang di dalam perulangan dengan cara itu bersifat kuadratik; untuk apa pun yang cukup besar, catat sendiri posisi tulisanmu atau pakai snprintf, yang dibahas di halaman konversi string.

strcmp: Membandingkan

== membandingkan alamat, jadi hasilnya salah untuk dua array berbeda yang berisi teks yang sama. strcmp membandingkan karakternya dan mengembalikan tanda dari selisihnya.

#include <stdio.h>
#include <string.h>

int main(void) {
    char a[] = "apple";
    char b[] = "apple";
    char c[] = "banana";

    const char *pa = a;
    const char *pb = b;
    printf("pa == pb (addresses)? %s\n", pa == pb ? "yes" : "no");
    printf("strcmp(a, b) == 0?  %s\n", strcmp(a, b) == 0 ? "yes" : "no");

    printf("strcmp(a, c) sign: %s\n", strcmp(a, c) < 0 ? "a before c" : "a after c");
    return 0;
}

Tiga aturan:

• Uji strcmp(a, b) == 0 untuk kesamaan. Menulis if (strcmp(a, b)) berarti "jika keduanya berbeda", yang terbaca terbalik bagi hampir semua orang.
• Hanya tandanya yang terdefinisi. Jangan bandingkan hasilnya dengan 1 atau -1.
• Urutannya berdasarkan nilai byte, jadi "Zebra" berada sebelum "apple" di ASCII. Untuk perbandingan yang tidak membedakan huruf besar dan kecil, ubah dulu kedua salinannya menjadi huruf kecil. strcasecmp yang sering terlihat adalah ekstensi POSIX, bukan C standar.

strncmp(a, b, n) hanya membandingkan n karakter pertama, dan ini cara yang rapi untuk menguji sebuah prefiks:

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *url = "https://coddy.tech";

    if (strncmp(url, "https://", 8) == 0) {
        printf("secure URL\n");
    }
    return 0;
}

strchr dan strstr: Mencari

strchr(s, ch) mencari kemunculan pertama sebuah karakter; strrchr mencari yang terakhir. strstr(haystack, needle) mencari sebuah substring. Ketiganya mengembalikan pointer ke dalam string aslinya, atau NULL jika tidak ada yang cocok.

#include <stdio.h>
#include <string.h>

int main(void) {
    char email[] = "ada@coddy.tech";

    char *at = strchr(email, '@');
    if (at != NULL) {
        printf("'@' at index %td\n", at - email);
        printf("domain: %s\n", at + 1);
    }

    char *dot = strrchr(email, '.');
    printf("extension: %s\n", dot != NULL ? dot + 1 : "(none)");

    if (strstr(email, "coddy") != NULL) {
        printf("contains \"coddy\"\n");
    }
    return 0;
}

Mengurangkan pointer hasil dengan awal string memberimu indeksnya; tipenya ptrdiff_t, dicetak dengan %td. Karena hasilnya menunjuk ke dalam array aslinya, at + 1 adalah sisa string tanpa penyalinan sama sekali. Ini idiom C yang sangat umum.

Selalu cek NULL sebelum melakukan dereference. strchr(email, '@') + 1 pada string tanpa @ menghitung alamat dari NULL, dan perilaku program tidak lagi terdefinisi.

Memecah String

Tidak ada fungsi split, tetapi strchr ditambah sebuah terminator bisa melakukannya langsung di tempat. Contoh ini memotong email menjadi bagian user dan domain:

#include <stdio.h>
#include <string.h>

int main(void) {
    char input[] = "ada@coddy.tech";
    char user[32];
    char domain[64];

    char *at = strchr(input, '@');
    if (at == NULL) {
        printf("not an email address\n");
        return 1;
    }

    size_t user_len = (size_t)(at - input);
    if (user_len >= sizeof user) {
        printf("user part too long\n");
        return 1;
    }

    memcpy(user, input, user_len);
    user[user_len] = '\0';

    strncpy(domain, at + 1, sizeof domain - 1);
    domain[sizeof domain - 1] = '\0';

    printf("user:   %s\n", user);
    printf("domain: %s\n", domain);
    return 0;
}

memcpy menyalin jumlah byte yang pasti tanpa peduli soal terminator, dan itulah yang kamu inginkan ketika panjangnya sudah diketahui. Terminatornya lalu ditulis secara manual.

Contoh Lengkap: Merapikan Nama

Menggabungkan semua yang sudah dibahas: memangkas, membandingkan, menyalin, dan menggabungkan:

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

int main(void) {
    char first[32] = "  ada  ";
    char last[32]  = "lovelace";
    char full[80];

    /* skip leading spaces */
    char *start = first;
    while (*start == ' ') {
        start++;
    }

    /* cut trailing spaces */
    size_t len = strlen(start);
    while (len > 0 && start[len - 1] == ' ') {
        start[--len] = '\0';
    }

    /* capitalize the first letter of each part */
    start[0] = (char)toupper((unsigned char)start[0]);
    last[0]  = (char)toupper((unsigned char)last[0]);

    /* join with a bounded copy */
    strncpy(full, start, sizeof full - 1);
    full[sizeof full - 1] = '\0';
    strncat(full, " ", sizeof full - strlen(full) - 1);
    strncat(full, last, sizeof full - strlen(full) - 1);

    printf("[%s]\n", full);
    printf("is it Ada Lovelace? %s\n",
           strcmp(full, "Ada Lovelace") == 0 ? "yes" : "no");
    return 0;
}

Setiap penulisan dibatasi oleh sizeof milik tujuannya sendiri, dan setiap strncpy diikuti terminator eksplisit. Disiplin itu, jika diterapkan secara konsisten, adalah yang membuat kode string C menjadi aman.

Aturan Ukuran yang Perlu Diingat

• strcpy butuh strlen(src) + 1 byte kosong di tujuan.
• strcat butuh strlen(dst) + strlen(src) + 1.
• Setelah strncpy, tulis dst[n - 1] = '\0' sendiri.
• Untuk strncat, jumlahnya adalah ruang yang tersisa: sizeof dst - strlen(dst) - 1.
• Cek hasil strchr dan strstr terhadap NULL sebelum memakainya.
• Pakai sizeof dst hanya jika dst adalah array sungguhan. Di dalam fungsi yang menerima char *dst, sizeof memberikan ukuran pointer, jadi kirim panjang buffer sebagai parameter terpisah.