Pada standar C sebelum C99, ukuran array harus berupa konstanta yang dievaluasi saat kompilasi. Ini membatasi fleksibilitas: kita harus memilih ukuran maksimum di muka, lalu menghabiskan memori sebesar itu bahkan saat data aktual hanya sedikit. C99 memperkenalkan Variable Length Arrays (VLA)—array yang ukurannya ditentukan oleh variabel biasa saat runtime. Pada chapter ini kita akan menelusuri sintaks VLA, kapan VLA berguna, serta risiko stack overflow yang harus kita waspadai.

Apa Itu VLA #

VLA adalah array yang ukurannya ditentukan oleh ekspresi (biasanya variabel) saat runtime, bukan konstanta compile-time. Sintaksnya mirip array biasa, tetapi angka di dalam [] adalah ekspresi yang dievaluasi saat program mencapai deklarasi. VLA dialokasikan di stack (bukan di heap), sehingga otomatis dibebaskan saat scope keluar.

VLA dengan Input Runtime #

Contoh berikut meminta pengguna memasukkan jumlah elemen, lalu mendeklarasikan array berukuran sesuai input.

c 
#include <stdio.h>

/* Fungsi dengan parameter VLA (C99) */
void cetak_matriks(int baris, int kolom, int m[baris][kolom]) {
    for (int i = 0; i < baris; i++) {
        for (int j = 0; j < kolom; j++) {
            printf("%4d", m[i][j]);
        }
        printf("\n");
    }
}

int main(void) {
    int n;
    printf("Masukkan jumlah elemen (kecil, mis. 5): ");
    if (scanf("%d", &n) != 1 || n <= 0) {
        printf("Input tidak valid.\n");
        return 1;
    }

    /* VLA: ukuran ditentukan saat runtime */
    int data[n];

    /* Isi dengan kuadrat */
    for (int i = 0; i < n; i++) {
        data[i] = (i + 1) * (i + 1);
    }

    printf("Kuadrat 1..%d:\n", n);
    for (int i = 0; i < n; i++) {
        printf("  %d^2 = %d\n", i + 1, data[i]);
    }

    /* VLA 2D */
    int r = 2, c = 3;
    int grid[r][c];
    int counter = 1;
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            grid[i][j] = counter++;
        }
    }
    printf("\nMatriks %dx%d:\n", r, c);
    cetak_matriks(r, c, grid);

    return 0;
}

Output yang Dihasilkan (input 5):

text 
Masukkan jumlah elemen (kecil, mis. 5): Kuadrat 1..5:
  1^2 = 1
  2^2 = 4
  3^2 = 9
  4^2 = 16
  5^2 = 25

Matriks 2x3:
   1   2   3
   4   5   6

Mari kita telaah baris-baris kode di atas:

  1. Baris 4 (void cetak_matriks(int baris, int kolom, int m[baris][kolom])): parameter VLA 2D. baris dan kolom harus dideklarasikan sebelum parameter m agar compiler mengetahui ukurannya. Sintaks ini hanya valid di C99+.
  2. Baris 16-19 (if (scanf("%d", &n) != 1 || n <= 0)): validasi input. Memastikan scanf berhasil membaca satu integer dan nilainya positif. Bila gagal, program keluar dengan kode 1 (error).
  3. Baris 23 (int data[n];): deklarasi VLA. Ukuran n ditentukan saat runtime—compiler menghasilkan instruksi untuk mengalokasikan n * sizeof(int) byte di stack saat eksekusi mencapai baris ini.
  4. Baris 26-28 (data[i] = (i + 1) * (i + 1);): mengisi elemen dengan kuadrat. Pola iterasi sama dengan array biasa.
  5. Baris 34-35 (int r = 2, c = 3; int grid[r][c];): VLA 2D dengan ukuran dari variabel r dan c. Total elemen = r * c = 6.
  6. Baris 36-40 (loop isi grid): nested loop mengisi elemen dengan nilai 1 sampai 6.
  7. Baris 42 (cetak_matriks(r, c, grid);): memanggil fungsi dengan parameter VLA. Karena r dan c diteruskan sebelum grid, fungsi tahu ukuran array.

VLA untuk Penjumlahan Barisan #

Contoh kedua memperlihatkan VLA untuk kasus klasik: menjumlahkan 1 + 2 + ... + n dengan n dari input.

c 
#include <stdio.h>

int main(void) {
    int n;
    printf("Berapa banyak angka yang akan dijumlahkan? ");
    if (scanf("%d", &n) != 1 || n <= 0) {
        printf("Input tidak valid.\n");
        return 1;
    }

    /* VLA berukuran n */
    int angka[n];

    long long total = 0;
    for (int i = 0; i < n; i++) {
        angka[i] = i + 1;
        total += angka[i];
    }

    printf("1 + 2 + ... + %d = %lld\n", n, total);
    printf("Cek formula n(n+1)/2 = %lld\n", (long long)n * (n + 1) / 2);

    return 0;
}

Output yang Dihasilkan (input 3):

text 
Berapa banyak angka yang akan dijumlahkan? 1 + 2 + ... + 3 = 6
Cek formula n(n+1)/2 = 6

Pada contoh di atas, ukuran array angka ditentukan oleh variabel n yang dibaca dari input. Akumulator total memakai tipe long long untuk menghindari overflow bila n besar—jumlah 1 + 2 + ... + n tumbuh kuadratik dan bisa melebihi batas int (sekitar 2 miliar) saat n di atas 65.000. Verifikasi dengan formula n*(n+1)/2 mengkonfirmasi perhitungan iteratif benar.