Pointer dan array di C: decay, arr[i] = *(arr+i), dan jebakan sizeof

Array dan pointer adalah dua hal yang berbeda di C, tapi sebagian besar waktu perilakunya sama. "Sebagian besar waktu" itulah yang membuat topik ini licin: kode yang memperlakukan array sebagai pointer biasanya bekerja, sampai suatu hari kode itu masuk ke salah satu dari dua tempat di mana perbedaannya penting, dan jawabannya diam-diam salah.

Halaman ini menarik garis pembatasnya dengan tepat.

Array decay: satu aturan di balik semuanya

Di hampir setiap ekspresi, nama array otomatis dikonversi menjadi pointer ke elemen pertamanya. Ini disebut decay. arr menjadi &arr[0], dengan tipe int *.

#include <stdio.h>

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

    printf("arr      = %p\n", (void *)arr);       // decays to &arr[0]
    printf("&arr[0]  = %p\n", (void *)&arr[0]);   // the same address
    printf("*arr     = %d\n", *arr);              // 10, the first element

    int *p = arr;                                  // no & needed - decay does it
    printf("*p       = %d\n", *p);

    return 0;
}

Nama array dan alamat elemen pertamanya tercetak sama persis. Itulah decay yang sedang bekerja, dan karena itulah kamu bisa memberikan array ke pointer tanpa &.

Hanya ada tepat tiga tempat decay tidak terjadi: sebagai operand sizeof, sebagai operand &, dan saat menginisialisasi array karakter dari string literal. Di tempat lain, anggap saja decay terjadi.

arr[i] secara harfiah adalah *(arr + i)

Standar C mendefinisikan operator subscript lewat aritmetika pointer: a[b] berarti *(a + b). Pengindeksan bukan fitur terpisah: itu hanya singkatan.

#include <stdio.h>

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

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d   *(arr + %d) = %d\n",
               i, arr[i], i, *(arr + i));
    }

    int *p = arr;
    printf("\np[2] = %d  (a pointer can be subscripted too)\n", p[2]);
    printf("2[arr] = %d  (legal, because addition commutes)\n", 2[arr]);

    return 0;
}

Ada dua akibatnya. Pertama, pointer bisa diberi subscript: p[2] adalah *(p + 2), dan karena itulah fungsi yang menerima pointer tetap bisa memakai sintaks arr[i] yang sudah akrab. Kedua, 2[arr] bisa dikompilasi: *(2 + arr) adalah alamat yang sama dengan *(arr + 2). Tidak ada yang menulisnya selain di kuis, tapi itu menjawab pertanyaan apakah pengindeksan "sebenarnya" adalah aritmetika pointer.

Mengirim array ke fungsi

Karena decay, sebuah fungsi tidak pernah menerima array. Fungsi menerima pointer.

#include <stdio.h>

// these three declarations are IDENTICAL to the compiler
int sum_a(int arr[], int n);
int sum_b(int arr[100], int n);   // the 100 is ignored entirely
int sum_c(int *arr, int n);

int sum_c(int *arr, int n) {
    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];

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

    // works on a slice too - a pointer is just a starting position
    printf("tail  = %d\n", sum_c(data + 3, 3));

    return 0;
}

Ada tiga hal yang layak diambil dari contoh itu.

Ukuran di int arr[100] hanyalah dokumentasi, tidak lebih. Compiler menulis ulang parameternya menjadi int *arr dan tidak pernah memeriksa apakah kamu benar-benar mengirim 100 elemen.

Panjangnya harus dikirim terpisah. Fungsi hanya punya alamat dan tidak tahu seberapa jauh datanya membentang. Karena itulah hampir semua fungsi C yang menerima array juga menerima jumlah: memcpy(dst, src, n), fread(ptr, size, count, f), qsort(base, nmemb, size, cmp). String adalah pengecualian hanya karena membawa penanda akhirnya sendiri, yaitu '\0'.

Mengirim pointer itu murah dan datanya dipakai bersama. Tidak ada salinan array yang dibuat, jadi fungsi bisa mengubah elemen milik pemanggil, dan sering kali memang itulah yang kamu inginkan:

#include <stdio.h>

void double_all(int *arr, int n) {
    for (int i = 0; i < n; i++) {
        arr[i] *= 2;
    }
}

void print_all(const int *arr, int n) {   // const: promises not to modify
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

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

    print_all(values, 5);
    double_all(values, 5);
    print_all(values, 5);      // the caller's array really changed

    return 0;
}

Tandai parameter yang hanya dibaca dengan const int * seperti yang dilakukan print_all. Itu mendokumentasikan maksudnya dan membuat compiler bisa menangkap penulisan yang tidak disengaja.

Jebakan sizeof

Inilah bug yang pernah menjebak setiap programmer C sekali. sizeof adalah salah satu dari dua tempat decay tidak terjadi, jadi operator itu memberi ukuran array yang sebenarnya di tempat array itu dideklarasikan, dan ukuran sebuah pointer di mana pun array itu sudah mengalami decay.

#include <stdio.h>

void inspect(int arr[]) {
    printf("inside function: sizeof(arr) = %zu\n", sizeof arr);
    printf("inside function: computed length = %zu  <-- WRONG\n",
           sizeof arr / sizeof arr[0]);
}

int main(void) {
    int data[10] = {0};

    printf("in main: sizeof(data) = %zu\n", sizeof data);
    printf("in main: length = %zu  <-- correct\n",
           sizeof data / sizeof data[0]);

    inspect(data);
    return 0;
}

Di main, sizeof data bernilai 40 byte dan panjangnya terhitung 10. Di dalam inspect, sizeof arr adalah ukuran pointer, 8 di mesin 64-bit, dan "panjangnya" keluar sebagai 2. Kodenya kelihatan sama persis dan diam-diam salah.

Aturan yang mengikutinya: hitung panjang array hanya di scope tempat array itu dideklarasikan, lalu kirim nilai itu dari sana.

& pada array bukan tipe yang sama

Tempat lain decay tidak terjadi adalah operator &. &arr adalah pointer ke seluruh array, bukan ke elemen pertamanya. Keduanya menyimpan alamat yang sama; bedanya ada pada arti "tambah 1".

#include <stdio.h>

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

    printf("arr      = %p   arr + 1  = %p\n",
           (void *)arr, (void *)(arr + 1));      // steps 4 bytes (one int)
    printf("&arr     = %p   &arr + 1 = %p\n",
           (void *)&arr, (void *)(&arr + 1));    // steps 20 bytes (the array)

    return 0;
}

Alamat awalnya sama, langkahnya berbeda. arr bertipe int * dan melangkah satu elemen; &arr bertipe int (*)[5] dan melangkah sebesar seluruh array. Inilah mekanisme yang membuat pengiriman satu baris array 2D bisa bekerja, yang dibahas di array multidimensi.

Pointer ke array vs array berisi pointer

Dua deklarasi yang kelihatan mirip tapi artinya berlawanan:

int *p[5];     // array of 5 pointers to int
int (*q)[5];   // pointer to an array of 5 ints

[] punya prioritas lebih tinggi daripada *, jadi int *p[5] dibaca sebagai "p adalah array, berisi pointer". Tanda kurung di int (*q)[5] memaksa * terikat lebih dulu: "q adalah pointer, ke sebuah array".

int *p[5]                     int (*q)[5]

 p[0] -> [ int ]               q -> [ int | int | int | int | int ]
 p[1] -> [ int ]                     one contiguous block of 5
 p[2] -> [ int ]
 p[3] -> [ int ]
 p[4] -> [ int ]
 five separate addresses

Array berisi pointer adalah yang umum, dan kamu sudah pernah memakainya: char *argv[] adalah array berisi pointer ke string, satu untuk setiap argumen baris perintah. Begitu juga caramu menyimpan daftar string yang panjangnya berbeda-beda tanpa membuang tempat.

#include <stdio.h>

int main(void) {
    // array of pointers: each entry points to a string of its own length
    const char *days[] = {"Monday", "Tuesday", "Wednesday"};
    int n = sizeof days / sizeof days[0];

    for (int i = 0; i < n; i++) {
        printf("%d: %s\n", i, days[i]);
    }

    // pointer to an array of 5 ints
    int block[5] = {1, 2, 3, 4, 5};
    int (*q)[5] = &block;

    printf("via q: %d %d\n", (*q)[0], (*q)[4]);
    printf("sizeof(*q) = %zu bytes (the whole array)\n", sizeof *q);

    return 0;
}

Perhatikan (*q)[0]: dereference pointernya untuk mendapat array, lalu indeks array itu. Tanda kurungnya lagi-lagi wajib, dengan alasan prioritas yang sama.

Di mana array dan pointer benar-benar berbeda

Ingat tabel singkat ini dan kebingungannya akan hilang:

Nama array bukan variabel yang menyimpan alamat: nama array adalah tempat penyimpanannya, dan alamatnya dihitung saat dibutuhkan. Karena itulah kamu tidak bisa memberinya nilai baru.