Karena string di C tidak menyimpan panjangnya sendiri, kita sering perlu menghitung jumlah karakter sebelum null terminator. Fungsi strlen dari header <string.h> melakukan pekerjaan ini dengan mengiterasi byte demi byte hingga menemui '\0'. Fungsi ini mengembalikan tipe size_t (bilangan tak bertanda) dan tidak menghitung null terminator itu sendiri. Pada chapter ini kita akan membandingkan strlen dengan sizeof, mengimplementasikan strlen versi manual untuk memahami mekanismenya, dan menggunakan strlen sebagai batas iterasi untuk pengolahan karakter string.

Penggunaan Dasar strlen #

Fungsi strlen menerima argumen const char * dan mengembalikan jumlah karakter sebelum null terminator. Mari kita lihat perilakunya pada string dengan berbagai panjang.

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

int main(void) {
    char s1[] = "Belajar";
    char s2[] = "";
    char s3[] = "Halo dunia!";

    /* strlen mengembalikan jumlah karakter sebelum '\0' */
    printf("strlen(\"Belajar\")     = %zu\n", strlen(s1));
    printf("strlen(\"\")            = %zu\n", strlen(s2));
    printf("strlen(\"Halo dunia!\") = %zu\n", strlen(s3));

    /* Bandingkan dengan sizeof yang menyertakan null terminator */
    printf("sizeof s1 = %zu (mencakup null terminator)\n", sizeof s1);
    printf("sizeof s2 = %zu (hanya null terminator)\n", sizeof s2);
    return 0;
}

Output yang Dihasilkan:

text 
strlen("Belajar")     = 7
strlen("")            = 0
strlen("Halo dunia!") = 11
sizeof s1 = 8 (mencakup null terminator)
sizeof s2 = 1 (hanya null terminator)

Pada output di atas, strlen("Belajar") = 7 karena ada 7 karakter sebelum null terminator. strlen("") = 0 karena byte pertama string kosong sudah '\0'. strlen("Halo dunia!") = 11 dengan spasi dihitung sebagai karakter biasa. sizeof s1 = 8 karena array menyimpan 7 karakter + 1 byte null terminator. sizeof s2 = 1 karena string kosong hanya berisi null terminator.

Implementasi Manual strlen #

Memahami implementasi strlen membantu kita menghargai mengapa fungsi ini disebut “O(n)"—semakin panjang string, semakin banyak byte yang harus dipindai. Berikut implementasi manual yang meniru perilaku standard library.

c 
#include <stdio.h>

/* Implementasi strlen manual */
size_t strlen_manual(const char *s) {
    const char *awal = s;
    while (*s != '\0') {
        s++;
    }
    return (size_t)(s - awal);
}

int main(void) {
    char nama[] = "Siti Nurhaliza";
    printf("strlen_manual = %zu\n", strlen_manual(nama));
    printf("Iterasi: %zu + 1 = %zu byte (untuk null terminator)\n",
           strlen_manual(nama), strlen_manual(nama) + 1);
    return 0;
}

Output yang Dihasilkan:

text 
strlen_manual = 14
Iterasi: 14 + 1 = 15 byte (untuk null terminator)

Mari kita telaah baris-baris kode di atas:

  1. Baris 4 (size_t strlen_manual(const char *s)): fungsi menerima pointer ke string (tidak akan dimutasi karena const) dan mengembalikan size_t.
  2. Baris 5 (const char *awal = s;): kita menyimpan alamat awal string ke dalam pointer awal. Pointer ini akan dipakai untuk menghitung jarak (selisih alamat) di akhir.
  3. Baris 6-8 (while (*s != '\0') { s++; }): loop mengiterasi pointer s maju satu byte setiap iterasi selama byte yang ditunjuk bukan '\0'. Setelah loop berhenti, s menunjuk ke posisi null terminator.
  4. Baris 9 (return (size_t)(s - awal);): kita menghitung selisih alamat antara posisi akhir s dan posisi awal awal. Selisih ini sama dengan jumlah karakter yang dilewati, yaitu panjang string. Cast ke size_t untuk konsistensi tipe.
  5. Baris 14-15 (printf("strlen_manual = %zu\n", strlen_manual(nama));): memanggil fungsi manual dan mencetak hasilnya. Untuk "Siti Nurhaliza", panjangnya 14 karakter.
  6. Baris 16-17: mengingatkan bahwa buffer yang dibutuhkan untuk menyimpan string adalah strlen + 1 byte (karena null terminator). Untuk "Siti Nurhaliza", buffer minimal 15 byte.

strlen sebagai Batas Iterasi #

Salah satu pemakaian strlen yang umum adalah sebagai batas loop saat mengiterasi karakter string untuk pengolahan seperti menghitung vokal/konsonan, mengubah case, atau mengganti karakter tertentu.

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

int main(void) {
    /* Iterasi maju per character menggunakan strlen sebagai batas */
    char teks[] = "Pemrograman C";
    size_t panjang = strlen(teks);

    printf("Karakter per karakter:\n");
    for (size_t i = 0; i < panjang; i++) {
        printf("  [%zu] = %c\n", i, teks[i]);
    }

    /* Pisahkan vokal dan konsonan */
    int vokal = 0, konsonan = 0;
    for (size_t i = 0; i < panjang; i++) {
        char c = teks[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u'||
            c=='A'||c=='E'||c=='I'||c=='O'||c=='U') {
            vokal++;
        } else if ((c>='a'&&c<='z')||(c>='A'&&c<='Z')) {
            konsonan++;
        }
    }
    printf("Vokal: %d, Konsonan: %d\n", vokal, konsonan);
    return 0;
}

Output yang Dihasilkan:

text 
Karakter per karakter:
  [0] = P
  [1] = e
  [2] = m
  [3] = r
  [4] = o
  [5] = g
  [6] = r
  [7] = a
  [8] = m
  [9] = a
  [10] = n
  [11] =  
  [12] = C
Vokal: 4, Konsonan: 8

Pada kode di atas, strlen(teks) dipanggil sekali dan disimpan ke panjang. Loop pertama memakai panjang sebagai batas untuk mencetak setiap karakter beserta indeksnya. Loop kedua juga memakai panjang untuk menghitung vokal dan konsonan. Spasi pada indeks 11 tidak masuk hitungan karena bukan vokal maupun konsonan. Hasil: 4 vokal (e, o, a, a) dan 8 konsonan (P, m, r, g, r, m, n, C).

Ringkasan Konsep #

Fungsi strlen menghitung jumlah karakter sebelum null terminator dan mengembalikan size_t. Fungsi ini bekerja dengan O(n) kompleksitas karena harus mengiterasi byte demi byte sampai menemui '\0'. Hasil strlen berbeda dari sizeof: strlen tidak menghitung null terminator; sizeof pada array char menghitung seluruh byte yang dialokasikan termasuk null terminator. Implementasi manual strlen cukup sederhana: simpan alamat awal, iterasi pointer sampai null terminator, lalu hitung selisih alamat akhir dan awal. Dalam praktik, simpan hasil strlen ke variabel lokal bila panjang dipakai berulang untuk menghindari pemanggilan fungsi O(n) berulang kali dalam loop. Pada chapter berikutnya kita akan masuk ke strcpy dan strncpy—fungsi untuk menyalin string dari satu buffer ke buffer lain.