Array di C: Deklarasi, Inisialisasi, dan Perulangan

Array adalah blok berukuran tetap yang berisi elemen bertipe sama, disusun berurutan di memori. Susunan yang bersambung inilah intinya: karena itu akses lewat indeks langsung cepat, array dan pointer sangat erat hubungannya, dan C bisa memberimu alamat elemen ke-nol lalu membiarkanmu menemukan elemen lain dengan aritmetika.

Mendeklarasikan Array

Tipe elemen, nama, dan ukuran di dalam kurung siku:

int    scores[5];       // 5 ints
double prices[100];     // 100 doubles
char   initials[3];     // 3 chars

Ukurannya adalah jumlah elemen, dan harus sudah diketahui di tempat array dideklarasikan. Biasanya berupa literal atau konstanta yang dibuat dengan #define. Memorinya langsung disediakan saat itu juga; tidak ada yang dialokasikan belakangan.

Array lokal yang baru dideklarasikan berisi nilai sampah, bukan nol:

#include <stdio.h>

int main(void) {
    int uninitialized[5];        // contents are indeterminate
    int zeroed[5] = {0};         // every element is 0

    printf("zeroed:        ");
    for (int i = 0; i < 5; i++) printf("%d ", zeroed[i]);

    printf("\nuninitialized: ");
    for (int i = 0; i < 5; i++) printf("%d ", uninitialized[i]);
    printf("   <-- whatever was in that memory\n");

    return 0;
}

Baris kedua bisa mencetak nol, bisa mencetak angka yang sangat besar, dan bisa berbeda di setiap run atau antara build debug dan build release. Membaca nilai-nilai itu adalah undefined behavior; inisialisasi dulu sebelum membacanya.

Inisialisasi

Ada beberapa bentuk, semuanya berguna:

#include <stdio.h>

int main(void) {
    int a[5] = {10, 20, 30, 40, 50};   // full list
    int b[5] = {1, 2};                 // rest are zero-filled: 1 2 0 0 0
    int c[5] = {0};                    // the whole array is zero
    int d[]  = {7, 8, 9};              // size deduced: 3 elements
    int e[5] = {[4] = 99, [0] = 1};    // designated initializers (C99)

    int n = sizeof d / sizeof d[0];

    printf("a: "); for (int i = 0; i < 5; i++) printf("%d ", a[i]);
    printf("\nb: "); for (int i = 0; i < 5; i++) printf("%d ", b[i]);
    printf("\nc: "); for (int i = 0; i < 5; i++) printf("%d ", c[i]);
    printf("\nd: "); for (int i = 0; i < n; i++) printf("%d ", d[i]);
    printf("  (size deduced as %d)", n);
    printf("\ne: "); for (int i = 0; i < 5; i++) printf("%d ", e[i]);
    printf("\n");

    return 0;
}

Pola {0} adalah yang paling perlu diingat: setiap elemen yang tidak kamu tulis akan diinisialisasi dengan nol, jadi satu angka nol membuat seluruh array bernilai nol. Designated initializer ([4] = 99) memungkinkanmu mengisi posisi tertentu dan membiarkan sisanya nol, yang praktis untuk tabel pencarian yang sebagian besar kosong.

Satu hal yang tidak bisa kamu lakukan adalah meng-assign array setelah dideklarasikan:

int a[3] = {1, 2, 3};
int b[3];
b = a;                    // error: an array is not assignable
memcpy(b, a, sizeof a);   // this is how you copy one

Indeks Dimulai dari Nol

Elemen pertama adalah arr[0] dan yang terakhir adalah arr[n-1]. Tidak ada arr[n].

#include <stdio.h>

int main(void) {
    int scores[5] = {88, 92, 75, 60, 100};

    printf("first  scores[0] = %d\n", scores[0]);
    printf("third  scores[2] = %d\n", scores[2]);
    printf("last   scores[4] = %d\n", scores[4]);

    scores[1] = 95;                       // write to an element
    printf("after update, scores[1] = %d\n", scores[1]);

    printf("\naddresses (note the even spacing):\n");
    for (int i = 0; i < 5; i++) {
        printf("  scores[%d] at %p\n", i, (void *)&scores[i]);
    }

    return 0;
}

Jalankan perulangan terakhir itu dan perhatikan alamatnya: setiap alamat berjarak tepat sizeof(int) byte dari alamat sebelumnya. Elemen-elemennya memang tersusun berdampingan:

 index      0         1         2         3         4
         +--------+--------+--------+--------+--------+
 value   |   88   |   95   |   75   |   60   |  100   |
         +--------+--------+--------+--------+--------+
 offset   +0       +4       +8       +12      +16      bytes
          ^
          &scores[0], which is also what `scores` decays to

Indeks yang dimulai dari nol bukan pilihan asal. Dengan begitu, indeks menjadi offset dari awal array, persis yang dibutuhkan aritmetika alamat. scores[i] didefinisikan sebagai *(scores + i); lihat pointer dan array.

Mengetahui Panjang Array

C tidak menyimpan panjang array di mana pun saat program berjalan, tetapi compiler mengetahuinya, dan sizeof memberimu akses ke informasi itu:

#include <stdio.h>

int main(void) {
    double prices[] = {4.99, 12.50, 0.99, 7.25};

    printf("total bytes    = %zu\n", sizeof prices);
    printf("bytes per item = %zu\n", sizeof prices[0]);
    printf("length         = %zu\n", sizeof prices / sizeof prices[0]);

    return 0;
}

Pola yang dipakai adalah sizeof(arr) / sizeof(arr[0]). Membagi dengan arr[0], bukan dengan sizeof(double) yang ditulis langsung, membuat baris itu tetap benar kalau kamu mengganti tipe elemennya.

Jebakannya: cara ini hanya berlaku di tempat array dideklarasikan. Kirim array ke sebuah fungsi, maka parameternya adalah pointer, sehingga sizeof justru mengukur pointer. Biasanya 8 byte, yang menghasilkan "panjang" 1 atau 2. Karena itulah setiap fungsi di C yang menerima array juga menerima jumlah elemennya:

#include <stdio.h>

int sum(const int *arr, int n) {       // the length must be passed in
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    return total;
}

int main(void) {
    int data[6] = {3, 1, 4, 1, 5, 9};
    int n = sizeof data / sizeof data[0];   // computed HERE, where it is correct

    printf("length = %d\n", n);
    printf("sum    = %d\n", sum(data, n));

    return 0;
}

Menelusuri Array dengan Perulangan

Bentuk standarnya adalah for loop dari 0 selama i < n:

#include <stdio.h>

int main(void) {
    int temps[7] = {18, 21, 25, 22, 19, 17, 24};
    int n = sizeof temps / sizeof temps[0];

    int total = 0, hottest = temps[0], coldest = temps[0];

    for (int i = 0; i < n; i++) {
        total += temps[i];
        if (temps[i] > hottest) hottest = temps[i];
        if (temps[i] < coldest) coldest = temps[i];
    }

    printf("readings: ");
    for (int i = 0; i < n; i++) printf("%d ", temps[i]);

    printf("\naverage:  %.1f\n", (double)total / n);
    printf("hottest:  %d\n", hottest);
    printf("coldest:  %d\n", coldest);

    return 0;
}

Perhatikan i < n, bukan i <= n. Dengan n elemen, indeks yang valid adalah 0 sampai n - 1, jadi <= menjalankan satu putaran ekstra dan membaca melewati ujung array. Mengisi nilai awal hottest dan coldest dari temps[0], bukan dari 0, adalah kebiasaan lain yang patut ditiru: nilai maksimum yang dimulai dari nol diam-diam salah kalau semua datanya negatif.

Akses di Luar Batas Adalah Undefined Behavior

Bagian C inilah yang mengejutkan orang yang datang dari bahasa lain. Tidak ada pemeriksaan batas. Tidak saat kompilasi, tidak juga saat program berjalan. arr[10] pada array berisi lima elemen bukan error, melainkan perhitungan alamat yang dilakukan compiler tanpa komentar apa pun.

int arr[5] = {1, 2, 3, 4, 5};
arr[7] = 99;     // writes 8 bytes past the end of the array
int x = arr[-1]; // reads before the start

Apa yang terjadi selanjutnya adalah undefined behavior, dan gejalanya sangat beragam, sayangnya:

• terlihat berjalan normal, karena memori yang tertimpa kebetulan tidak dipakai;
• variabel lain berubah tanpa alasan yang terlihat;
• program crash dengan segmentation fault, mungkin jauh setelahnya;
• perilakunya berbeda antara -O0 dan -O2.

"Terlihat berjalan normal" adalah yang paling berbahaya, karena artinya bug itu ikut dirilis. Tiga cara bertahan:

1. Gunakan i < n di perulangan. Sebagian besar akses yang kebablasan adalah kesalahan off-by-one di kondisi perulangan.
2. Validasi indeks yang berasal dari input.

#include <stdio.h>

int main(void) {
    int arr[5] = {10, 20, 30, 40, 50};
    int n = 5;

    int requests[4] = {2, 5, -1, 4};    // two of these are out of range

    for (int i = 0; i < 4; i++) {
        int idx = requests[i];
        if (idx >= 0 && idx < n) {
            printf("arr[%d] = %d\n", idx, arr[idx]);
        } else {
            printf("index %d rejected (valid range is 0..%d)\n", idx, n - 1);
        }
    }

    return 0;
}

3. Build dengan sanitizer selama pengembangan. gcc -fsanitize=address -g prog.c mengubah sebagian besar akses kebablasan menjadi laporan langsung yang menyebutkan file, baris, dan array yang terlibat.

Array dengan Tipe Lain

Sintaks yang sama berlaku untuk tipe elemen apa pun, termasuk struct:

#include <stdio.h>

typedef struct {
    const char *name;
    int         score;
} Player;

int main(void) {
    Player players[3] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Ken",   85}
    };
    int n = sizeof players / sizeof players[0];

    for (int i = 0; i < n; i++) {
        printf("%-6s %3d\n", players[i].name, players[i].score);
    }

    // an array of char is a string when it ends with '\0'
    char word[6] = "hello";        // 5 characters plus the terminator
    printf("\nword = %s (%zu bytes of storage)\n", word, sizeof word);

    return 0;
}

Baris char word[6] = "hello"; layak diperhatikan sebentar: string di C hanyalah array char yang byte bermakna terakhirnya adalah '\0'. Karena terminator itulah array ini butuh enam slot untuk lima huruf.

Sekilas tentang Variable-Length Array

C99 mengizinkan array yang ukurannya berupa nilai saat program berjalan:

int n = get_count();
int buffer[n];        // a variable-length array

Ada dua peringatan. Ukurannya tetap begitu array dibuat, jadi VLA bukan list yang bisa bertambah panjang. Lalu memorinya berasal dari stack, sehingga n yang besar atau dikendalikan penyerang bisa membuat stack meluap dan program crash. Karena itu banyak proyek, termasuk kernel Linux, melarang VLA sama sekali. Implementasi C11 juga tidak wajib mendukungnya.

Kalau ukurannya benar-benar baru diketahui saat program berjalan, alokasikan memori:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 6;                              // pretend this came from input

    int *arr = malloc(n * sizeof *arr);     // heap, not stack
    if (arr == NULL) {
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = (i + 1) * (i + 1);
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);              // indexing works exactly the same
    }
    printf("\n");

    free(arr);
    return 0;
}

Perhatikan bahwa arr[i] terbaca sama saja, baik arr berupa array maupun pointer ke memori yang dialokasikan: sintaks indeks tidak peduli. Detail lengkapnya ada di memori dinamis.