Sejauh ini kita menyimpan data dalam satu variabel per nilai: satu int untuk umur, satu std::string untuk nama. Padahal sering kali kita butuh wadah untuk banyak nilai yang setipe, misalnya lima nilai ujian atau seratus suhu harian. Array adalah koleksi elemen bertipe sama yang disimpan berurutan dalam memori, dan array C-style adalah bentuk paling dasarnya karena sintaksnya diwarisi langsung dari bahasa C. Pada Chapter ini kita mempelajari cara mendeklarasikan array C-style, memahami tata letak memorinya, dan mengetahui kelemahan yang melatarbelakangi lahirnya alternatif modern seperti std::array dan std::vector.

Deklarasi dan Pengisian Elemen #

Sintaks deklarasi array C-style adalah tipe nama[ukuran];. Pernyataan int angka[5]; menyuruh compiler menyiapkan lima slot int yang berdampingan dan diberi nama angka. Setiap slot disebut elemen dan diakses lewat indeks yang ditulis di dalam tanda kurung siku. Perhatikan program berikut yang mengisi dan membaca seluruh elemen:

cpp 
#include <iostream>

int main() {
    int angka[5];  // deklarasi: 5 slot int berurutan, indeks 0 sampai 4

    // mengisi elemen satu per satu lewat indeks
    angka[0] = 10;
    angka[1] = 20;
    angka[2] = 30;
    angka[3] = 40;
    angka[4] = 50;

    // membaca kembali semua elemen
    for (int i = 0; i < 5; ++i) {
        std::cout << "angka[" << i << "] = " << angka[i] << "\n";
    }

    // ukuran total dalam byte dan jumlah elemen
    std::cout << "sizeof(angka) = " << sizeof(angka) << " byte\n";
    std::cout << "jumlah elemen = " << sizeof(angka) / sizeof(angka[0]) << "\n";

    // jarak antar elemen di memori (dalam satuan elemen, bukan byte)
    std::cout << "jarak angka[0] ke angka[1]: " << (&angka[1] - &angka[0])
              << " elemen\n";

    return 0;
}

Output yang Dihasilkan:

text 
angka[0] = 10
angka[1] = 20
angka[2] = 30
angka[3] = 40
angka[4] = 50
sizeof(angka) = 20 byte
jumlah elemen = 5
jarak angka[0] ke angka[1]: 1 elemen

Mari kita bedah baris demi baris:

  1. Baris 5 (int angka[5];): compiler memesan lima slot int sekaligus. Nilai awalnya tidak ditentukan oleh standar — array lokal tanpa inisialisasi berisi sampah memori, jadi kita mengisi semua slot sebelum membacanya.
  2. Baris 8-12 (angka[0] = 10; dst.): operator kurung siku [] mengakses elemen pada indeks tertentu, baik untuk menulis maupun membaca. Ekspresi angka[2] = 30; menaruh nilai 30 pada slot ketiga.
  3. Baris 15-18 (loop for): kita memakai loop yang sudah dipelajari pada Section Control Flow untuk menelusuri indeks 0 sampai 4. Pola for (int i = 0; i < 5; ++i) adalah pola standar perulangan array.
  4. Baris 21-22 (sizeof(angka)): operator sizeof mengembalikan ukuran total array dalam byte, yaitu 5 * sizeof(int) = 5 * 4 = 20 pada platform ini. Membaginya dengan sizeof(angka[0]) memberi jumlah elemen — trik klasik untuk menghitung panjang array C-style.
  5. Baris 25-26 (&angka[1] - &angka[0]): operator & mengambil alamat memori elemen (dibahas tuntas pada Section Pointer dan Reference). Selisih dua alamat dihitung dalam satuan elemen, dan hasilnya 1 menegaskan bahwa elemen yang berdekatan indeksnya juga berdampingan di memori.

Memori yang Berurutan (Contiguous) #

Kata kunci penting array C-style adalah contiguous: kelima elemennya menempati blok memori yang berkesinambungan tanpa celah. Untuk int angka[5] dengan sizeof(int) sebesar 4 byte, compiler menata memorinya seperti ini:

text 
alamat:      awal   awal+4  awal+8  awal+12 awal+16
indeks:      [0]    [1]     [2]     [3]     [4]
isi:         10     20      30      40      50

Tata letak ini menjelaskan dua sifat array. Pertama, akses angka[i] sangat cepat karena compiler dapat menghitung alamat elemen dengan rumus awal + i * sizeof(int) — satu operasi aritmetika, tanpa pencarian. Kedua, ukuran array harus diketahui saat kompilasi karena compiler perlu tahu berapa banyak slot yang harus dipesan sebelum program berjalan.

Ukuran Tetap dan Keterbatasannya #

Ukuran array C-style bersifat fixed-size: ditentukan sekali saat menulis kode dan tidak bisa bertambah atau berkurang saat program berjalan. Apabila kita butuh lima nilai lalu ternyata butuh enam, satu-satunya jalan adalah menulis array baru dengan ukuran lebih besar dan menyalin isi array lama secara manual. Mekanisme alokasi memori dinamis yang membuat ukuran berubah saat runtime dibahas pada Section Manajemen Memori.

Ada satu kelemahan lain yang sering mengejutkan: ketika array dikirim ke sebuah fungsi, informasi ukurannya ikut hilang karena array “meluruh” menjadi pointer ke elemen pertama — istilahnya array decay. Kita akan membuktikannya secara langsung pada Chapter Array sebagai Parameter Fungsi. Untuk saat ini cukup diingat: array C-style tidak membawa ukurannya sendiri, dan kita yang harus mengingatnya.

Chapter berikutnya membahas cara mengisi array dengan benar sejak awal memakai initializer list, termasuk perilaku nol pada elemen yang tidak kita isi, sehingga kita tidak pernah membaca sampah memori tanpa sadar.

Rujukan resmi: cppreference — Declarations: Array .