1. Pendahuluan

Bahasa pemrograman “C” dikenal karena kesederhanaan dan kinerjanya yang tinggi, sehingga digunakan secara luas di berbagai bidang seperti pengembangan sistem dan sistem tertanam (embedded system). Di antara berbagai fitur C, “array” adalah struktur data penting untuk mengelola kumpulan data, dan sering digunakan dalam banyak program.

Artikel ini akan membahas secara detail tentang “cara mendapatkan panjang array” dalam bahasa C. Fokusnya adalah pada poin-poin yang sering membingungkan pemula, dengan penjelasan dari dasar hingga penerapan, sehingga Anda dapat memahami dan menguasai keterampilan untuk menghitung panjang array secara akurat.

2. Konsep Dasar Array

Apa itu Array?

Array adalah struktur data yang memungkinkan pengelolaan sekelompok nilai dengan tipe data yang sama. Array menyimpan data dengan tipe yang sama secara berurutan di memori, sehingga memudahkan pemrosesan data dalam jumlah banyak sekaligus.

Kegunaan Array

1. Pemrosesan data secara massal – Cocok untuk mengelola data sejenis seperti nilai ujian siswa atau data sensor.
2. Penggunaan dalam perulangan – Dapat diakses secara berurutan menggunakan loop, sehingga efisien untuk proses yang berulang.
3. Manajemen memori – Karena menempati ruang memori secara berurutan, akses data menjadi lebih cepat dan efisien.

Cara Kerja Array

Array diakses menggunakan indeks (index). Dalam bahasa C, indeks dimulai dari 0, dan elemen terakhir diakses dengan “ukuran array – 1”.

Contoh:

int numbers[5] = {10, 20, 30, 40, 50};
printf("%dn", numbers[0]); // output: 10
printf("%dn", numbers[4]); // output: 50

Pada contoh di atas, array numbers menyimpan 5 bilangan integer dan setiap elemen dapat diakses menggunakan indeksnya.

3. Deklarasi dan Inisialisasi Array

Cara Deklarasi Array

Dalam bahasa C, array dideklarasikan seperti ini:

tipe_data nama_array[ukuran];

Contoh:

int scores[10]; // array integer dengan 10 elemen

Contoh di atas mendeklarasikan array scores bertipe integer dengan 10 slot memori.

Inisialisasi Array

Array dapat diinisialisasi saat deklarasi.

1. Inisialisasi lengkap

int values[5] = {1, 2, 3, 4, 5};

2. Inisialisasi sebagian

int data[5] = {10, 20}; // sisanya diisi 0

3. Inisialisasi tanpa menentukan ukuran

int numbers[] = {10, 20, 30}; // ukuran otomatis dihitung menjadi 3

Catatan untuk Array yang Tidak Diinisialisasi

Menggunakan array tanpa inisialisasi dapat menghasilkan nilai acak (garbage value). Oleh karena itu, inisialisasi sangat dianjurkan.

4. Cara Mendapatkan Panjang (Jumlah Elemen) Array

Dalam bahasa C, mengetahui panjang (jumlah elemen) array secara akurat sangat penting. Terutama saat melakukan proses perulangan atau pengelolaan data, Anda harus mengetahui ukuran array. Bagian ini akan menjelaskan metode yang tepat dan hal-hal yang perlu diperhatikan.

4.1 Menggunakan Operator sizeof

Cara paling umum untuk mendapatkan panjang array adalah dengan menggunakan operator sizeof. Operator ini mengembalikan ukuran dalam byte dari tipe data atau variabel.

Contoh dasar

#include <stdio.h>

int main() {
    int array[5] = {10, 20, 30, 40, 50};
    int length = sizeof(array) / sizeof(array[0]); // menghitung jumlah elemen

    printf("Panjang array: %dn", length); // output: 5
    return 0;
}

Poin penting:

• sizeof(array) – Mendapatkan ukuran total array dalam byte.
• sizeof(array[0]) – Mendapatkan ukuran byte dari elemen pertama.
• Dengan membagi total ukuran array dengan ukuran satu elemen, kita mendapatkan jumlah elemen.

4.2 Catatan Saat Mengirim Array ke Fungsi

Saat array dikirim ke fungsi sebagai argumen, array akan dikonversi menjadi “pointer”. Akibatnya, sizeof hanya mengembalikan ukuran pointer (biasanya 4 atau 8 byte), bukan ukuran array sebenarnya.

Contoh masalah

#include <stdio.h>

void printArrayLength(int arr[]) {
    printf("Ukuran: %ldn", sizeof(arr) / sizeof(arr[0])); // tidak berfungsi dengan benar
}

int main() {
    int array[5] = {1, 2, 3, 4, 5};
    printArrayLength(array);
    return 0;
}

Solusi
Kirim panjang array sebagai argumen terpisah.

Contoh perbaikan

#include <stdio.h>

void printArrayLength(int arr[], int length) {
    printf("Panjang array: %dn", length);
}

int main() {
    int array[5] = {1, 2, 3, 4, 5};
    int length = sizeof(array) / sizeof(array[0]); // menghitung jumlah elemen
    printArrayLength(array, length);
    return 0;
}

5. Mendapatkan Panjang Array String

Dalam bahasa C, string juga diperlakukan sebagai array. Namun, berbeda dengan array angka, string adalah array bertipe char dan diakhiri dengan karakter khusus '\0' (null character). Bagian ini menjelaskan cara mendapatkan panjang array string dan hal-hal yang perlu diperhatikan.

5.1 Hubungan Antara String dan Array

String adalah kumpulan karakter yang direpresentasikan sebagai array char.

char str[] = "Hello";

Di memori, str disimpan seperti ini:

Poin penting:

• '\0' adalah karakter terminator yang menandakan akhir string.
• Ukuran array mencakup karakter terminator ini.

5.2 Menggunakan Fungsi strlen

Untuk mendapatkan panjang string (jumlah karakter), gunakan fungsi strlen dari pustaka standar.

Contoh kode:

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

int main() {
    char str[] = "Hello";
    printf("Panjang string: %ldn", strlen(str)); // output: 5
    return 0;
}

Catatan:

• strlen menghitung panjang string tanpa menyertakan karakter '\0'.

5.3 Perbedaan dengan Operator sizeof

Anda juga dapat menggunakan sizeof untuk mengetahui ukuran array string, tetapi hasilnya berbeda dengan strlen.

Contoh:

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

int main() {
    char str[] = "Hello";
    printf("sizeof: %ldn", sizeof(str));  // output: 6 (termasuk '\0')
    printf("strlen: %ldn", strlen(str)); // output: 5 (tanpa '\0')
    return 0;
}

Poin perbedaan:

• sizeof mengembalikan ukuran array secara keseluruhan (termasuk '\0').
• strlen hanya menghitung jumlah karakter tanpa '\0'.

6. Penanganan Array Berdimensi Panjang Variabel (VLA)

Dalam bahasa C, sejak standar C99 diperkenalkan fitur Variable Length Array (VLA). Fitur ini memungkinkan penentuan ukuran array saat runtime, bukan saat kompilasi. Bagian ini akan membahas karakteristik, cara penggunaan, dan hal-hal yang perlu diperhatikan saat menggunakan VLA.

6.1 Apa itu Variable Length Array (VLA)?

Array biasa adalah array statis yang ukurannya ditentukan saat kompilasi. Sebaliknya, VLA adalah array dinamis yang ukurannya dapat ditentukan saat program dijalankan, berdasarkan input pengguna atau hasil perhitungan.

Contoh array statis:

int arr[10]; // ukuran tetap saat kompilasi

Contoh Variable Length Array (VLA):

int size;
scanf("%d", &size); // menentukan ukuran saat runtime
int arr[size];      // array dialokasikan saat runtime

6.2 Cara Dasar Menggunakan VLA

Contoh berikut membuat array berdasarkan ukuran yang dimasukkan pengguna, lalu memprosesnya.

Contoh kode:

#include <stdio.h>

int main() {
    int n;

    printf("Masukkan ukuran array: ");
    scanf("%d", &n); // menentukan ukuran saat runtime

    int arr[n]; // deklarasi VLA

    // mengisi array
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

    // menampilkan isi array
    printf("Isi array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("n");

    return 0;
}

Contoh output:

Masukkan ukuran array: 5
Isi array: 1 2 3 4 5

Poin penting:

1. VLA memungkinkan pengaturan ukuran array secara fleksibel saat runtime.
2. Ukuran array tidak perlu diketahui saat program dikompilasi.

7. Hal-hal yang Perlu Diperhatikan tentang Panjang Array

Dalam bahasa C, manajemen ukuran (panjang) array sangat penting. Kesalahan dalam penghitungan panjang dapat menyebabkan program tidak berfungsi dengan benar atau bahkan menciptakan risiko keamanan. Bagian ini membahas risiko tersebut dan cara penanganannya.

7.1 Menghindari Akses di Luar Batas Array

Karena array memiliki ukuran tetap, mengakses indeks di luar batas akan menyebabkan perilaku tak terduga atau crash pada program.

Contoh: akses di luar batas

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i <= 5; i++) { // kondisi salah
        printf("%dn", arr[i]);  // akses di luar batas
    }

    return 0;
}

Solusi:

• Gunakan kondisi loop yang tepat

for (int i = 0; i < 5; i++) { // kondisi benar
    printf("%dn", arr[i]);
}

• Gunakan ukuran array secara dinamis

int length = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < length; i++) {
    printf("%dn", arr[i]);
}

7.2 Risiko Buffer Overflow

Salah satu masalah umum akibat kesalahan manajemen ukuran array adalah buffer overflow. Ini terjadi saat data ditulis melewati batas array, sehingga menimpa memori lain.

Contoh buffer overflow

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

int main() {
    char buffer[10]; // array 10 byte
    strcpy(buffer, "This string is too long!"); // melebihi kapasitas
    printf("%sn", buffer);
    return 0;
}

Solusi:

• Gunakan fungsi yang aman

strncpy(buffer, "This string is too long!", sizeof(buffer) - 1);
buffer[sizeof(buffer) - 1] = '\0'; // pastikan karakter terminator

8. Ringkasan

Artikel ini membahas konsep dasar hingga teknik lanjutan dalam menghitung panjang array di bahasa C. Array adalah struktur data yang sangat berguna, namun penggunaannya harus hati-hati agar tidak menimbulkan bug atau risiko keamanan.

8.1 Ringkasan Poin Penting

1. Konsep dasar array serta deklarasi & inisialisasi

• Array menyimpan elemen bertipe sama secara berurutan di memori.
• Ukuran array ditentukan saat deklarasi, namun dapat diinisialisasi dengan atau tanpa ukuran eksplisit.

1. Cara menghitung panjang array

• Gunakan sizeof untuk array statis.
• Jika array dikirim ke fungsi, panjang harus dikirim sebagai argumen terpisah.

1. Panjang array string

• Gunakan strlen untuk menghitung jumlah karakter, pahami perbedaan dengan sizeof.

1. Variable Length Array (VLA)

• Memberikan fleksibilitas ukuran saat runtime, namun ada batasan kompatibilitas dan risiko stack overflow.

1. Tips keamanan

• Hindari akses di luar batas dan buffer overflow dengan validasi ukuran serta penggunaan fungsi aman.

Pertanyaan yang Sering Diajukan (FAQ)

Q1: Mengapa saat menggunakan sizeof untuk mendapatkan panjang array, hasilnya salah ketika dipanggil di dalam fungsi?

A:
Operator sizeof hanya akan mengembalikan ukuran total array jika array tersebut dideklarasikan langsung dalam lingkup (scope) yang sama. Namun, saat array dikirim ke fungsi, array tersebut diubah menjadi pointer. Pointer hanya menyimpan alamat elemen pertama, sehingga sizeof akan mengembalikan ukuran pointer (biasanya 4 atau 8 byte), bukan jumlah elemen sebenarnya.

Solusi:
Kirim juga panjang array sebagai parameter terpisah saat memanggil fungsi.

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%dn", arr[i]);
    }
}

int main() {
    int array[5] = {1, 2, 3, 4, 5};
    printArray(array, sizeof(array) / sizeof(array[0])); // mengirim panjang array
    return 0;
}

Q2: Saat menghitung panjang string, kapan harus menggunakan sizeof dan kapan menggunakan strlen?

A:
Gunakan sesuai kebutuhan:

• sizeof: Mengembalikan ukuran total array dalam byte, termasuk karakter terminator '\0'. Cocok untuk memeriksa kapasitas buffer.
• strlen: Mengembalikan jumlah karakter aktual tanpa menghitung '\0'. Cocok untuk mengetahui panjang teks yang tersimpan.

Contoh:

char str[] = "Hello";
printf("%ldn", sizeof(str));  // output: 6 (termasuk '\0')
printf("%ldn", strlen(str)); // output: 5 (tanpa '\0')

Q3: Haruskah saya menggunakan Variable Length Array (VLA) atau alokasi memori dinamis (malloc)?

A:
Tergantung kebutuhan:

• Kelebihan VLA: Lebih sederhana digunakan, ukuran dapat ditentukan saat runtime. Namun, menggunakan memori stack sehingga berisiko stack overflow untuk ukuran besar. Tidak selalu tersedia di semua compiler (terutama C11 ke atas).
• Kelebihan malloc: Menggunakan memori heap sehingga dapat menangani data besar. Lebih aman untuk ukuran besar dan memiliki kompatibilitas lebih luas. Namun, perlu membebaskan memori dengan free().

Q4: Apa yang terjadi jika saya lupa membebaskan memori yang dialokasikan secara dinamis?

A:
Jika memori tidak dibebaskan setelah digunakan, akan terjadi kebocoran memori (memory leak). Jika kebocoran terjadi berulang, program atau sistem bisa melambat atau crash.

Solusi: Selalu gunakan free() setelah selesai menggunakan memori.

int *arr = malloc(10 * sizeof(int)); // alokasi memori
if (arr == NULL) {
    printf("Gagal mengalokasikan memorin");
    return 1;
}

// ... gunakan array ...

free(arr); // membebaskan memori

Q5: Apa saja hal yang harus diperhatikan untuk mencegah buffer overflow?

A:
Buffer overflow terjadi saat menulis data melebihi kapasitas array, menyebabkan data menimpa memori lain. Untuk mencegahnya:

1. Selalu periksa ukuran array sebelum menulis data

• Batasi jumlah data yang diinput sesuai kapasitas array.

1. Gunakan fungsi dengan batas ukuran

• Gunakan strncpy alih-alih strcpy, dan snprintf alih-alih sprintf.

1. Siapkan kapasitas ekstra

• Untuk string, selalu sisakan ruang untuk karakter '\0'.

1. Lakukan pengujian dengan nilai batas

• Uji kasus ekstrem dan periksa perilaku program.

Ringkasan

Bagian FAQ ini menjawab pertanyaan umum seputar perhitungan panjang array di bahasa C, baik untuk array biasa maupun string. Dengan memahami poin-poin ini, Anda dapat menulis program yang lebih aman dan efisien.