Aritmetika pointer di C: menambah, mengurangi, dan menelusuri memori

Pointer menyimpan alamat, dan alamat adalah angka, jadi wajar kalau kita berharap aritmetika bisa dipakai padanya. Memang bisa, tapi tidak persis seperti aritmetika integer biasa. C menskalakan setiap operasi pointer dengan ukuran hal yang ditunjuk, sehingga "tambah satu" berubah menjadi sesuatu yang jauh lebih berguna: "pindah ke elemen berikutnya".

Satu keputusan desain itulah yang membuat menelusuri array dengan pointer terasa sealami menelusurinya dengan indeks di C.

Menambah 1 berarti bergeser satu objek, bukan satu byte

Ambil sebuah pointer, tambahkan 1, lalu cetak kedua alamatnya:

#include <stdio.h>

int main(void) {
    int    i = 0;
    double d = 0.0;
    char   c = 0;

    int    *pi = &i;
    double *pd = &d;
    char   *pc = &c;

    printf("int    *: %p -> %p  (moved %td bytes)\n",
           (void *)pi, (void *)(pi + 1), (char *)(pi + 1) - (char *)pi);
    printf("double *: %p -> %p  (moved %td bytes)\n",
           (void *)pd, (void *)(pd + 1), (char *)(pd + 1) - (char *)pd);
    printf("char   *: %p -> %p  (moved %td bytes)\n",
           (void *)pc, (void *)(pc + 1), (char *)(pc + 1) - (char *)pc);

    return 0;
}

int * melompat 4 byte, double * melompat 8, char * melompat 1: masing-masing mendarat tepat di tempat objek berikutnya dengan tipe yang sama akan dimulai. Aturannya sederhana:

ptr + n  ==  (address in ptr) + n * sizeof(*ptr)

Persis karena inilah pointer punya tipe. Alamat polos tanpa tipe tidak akan tahu seberapa jauh "berikutnya" itu.

Menelusuri array dengan pointer

Sekarang hasilnya. Elemen-elemen array terletak di memori yang berurutan, jadi melangkahkan pointer akan mengunjunginya secara berurutan:

#include <stdio.h>

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

    printf("index form:   ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", scores[i]);
    }

    printf("\npointer form: ");
    for (int *p = scores; p < scores + 5; p++) {
        printf("%d ", *p);
    }
    printf("\n");

    return 0;
}

Kedua loop mencetak lima angka yang sama. Di loop kedua, scores berubah (decay) menjadi pointer ke elemen pertamanya, p++ maju sebesar satu int, dan *p membaca elemen yang ada di sana. Kalau digambarkan di memori:

 scores[0] scores[1] scores[2] scores[3] scores[4]
+---------+---------+---------+---------+---------+
|   88    |   92    |   75    |   60    |   100   |
+---------+---------+---------+---------+---------+
 ^         ^                                       ^
 p         p+1                                     scores+5
 (start)   (4 bytes later)                         (one past the end)

Hubungan antara kedua bentuk itu persis dan layak dihafal: scores[i] didefinisikan sebagai *(scores + i). Penjelasan lebih lanjut ada di halaman pointer dan array.

Increment, decrement, dan jebakan *p++

++ dan -- bekerja pada pointer dengan penskalaan yang sama.

#include <stdio.h>

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

    printf("*p        = %d\n", *p);      // 10
    p++;
    printf("after p++ = %d\n", *p);      // 20
    p += 2;
    printf("after p+=2= %d\n", *p);      // 40
    p--;
    printf("after p-- = %d\n", *p);      // 30

    return 0;
}

Ekspresi yang membingungkan semua orang adalah *p++. ++ postfix terikat lebih kuat daripada *, jadi artinya "ambil p saat ini, majukan p, lalu dereference nilai yang lama":

#include <stdio.h>

int main(void) {
    int data[3] = {1, 2, 3};
    int *p = data;

    int a = *p++;      // reads data[0], then p moves to data[1]
    printf("a = %d, *p is now %d\n", a, *p);

    int *q = data;
    (*q)++;            // parentheses: increment the VALUE, not the pointer
    printf("data[0] = %d, *q = %d\n", data[0], *q);

    int *r = data;
    int b = *++r;      // prefix: advance FIRST, then read
    printf("b = %d\n", b);

    return 0;
}

Tiga ekspresi, tiga arti yang berbeda:

*p++ adalah gaya C yang lazim, dan begitulah salinan string dan buffer ditulis, tapi tulislah tanda kurung kalau yang kamu maksud lain.

Mengurangkan dua pointer

Mengurangkan satu pointer dari pointer lain menghasilkan jumlah elemen di antara keduanya, bukan jumlah byte:

#include <stdio.h>

int main(void) {
    int arr[8] = {2, 4, 6, 8, 10, 12, 14, 16};

    int *start = arr;
    int *end   = arr + 8;      // one past the last element

    printf("length      = %td\n", end - start);

    // find the first element greater than 9 and report its index
    int *found = start;
    while (found < end && *found <= 9) {
        found++;
    }
    if (found != end) {
        printf("first > 9   = %d at index %td\n", *found, found - start);
    }

    return 0;
}

Tipe hasilnya adalah ptrdiff_t, tipe integer bertanda dari <stddef.h>, yang dicetak dengan %td. Mengurangkan pointer ke dua array yang berbeda menghasilkan nilai yang tidak terdefinisi: standarnya hanya mendefinisikan operasi ini di dalam satu objek.

Kamu juga bisa mengurangkan integer dari pointer (p - 3 mundur tiga elemen), tapi kamu tidak bisa menjumlahkan dua pointer. "Jumlah dua alamat" tidak bermakna apa-apa.

Membandingkan pointer

Operator relasional bekerja pada pointer ke dalam array yang sama, dan artinya persis seperti yang ditunjukkan tata letak memorinya: p < q bernilai benar saat p menunjuk elemen yang lebih awal.

#include <stdio.h>

int main(void) {
    char text[] = "stressed";
    char *front = text;
    char *back  = text + 7;      // last character, before the '\0'

    // reverse the string in place by walking two pointers toward each other
    while (front < back) {
        char temp = *front;
        *front = *back;
        *back  = temp;
        front++;
        back--;
    }

    printf("%s\n", text);
    return 0;
}

front < back adalah seluruh cerita tentang kapan loop itu berhenti, dan itu benar karena kedua pointer tetap berada di dalam satu array. == dan != juga cara alami untuk menguji loop terhadap penanda akhirnya, dan itu membawa kita ke aturan yang membuat semua ini sah.

Aturan satu-melewati-akhir

C secara eksplisit mengizinkanmu membentuk pointer ke posisi satu setelah elemen terakhir sebuah array. Kamu boleh menghitungnya, menyimpannya, dan membandingkan dengannya. Kamu tidak boleh melakukan dereference padanya.

int arr[4];

 arr[0]   arr[1]   arr[2]   arr[3]   (no element)
+------+ +------+ +------+ +------+  +- - - -+
|      | |      | |      | |      |  |       |
+------+ +------+ +------+ +------+  +- - - -+
 ^                                    ^
 arr                                  arr + 4
 legal to use                         legal to FORM and COMPARE
                                      never legal to dereference

Aturan itulah yang membuat bentuk loop standar ini valid:

for (int *p = arr; p != arr + n; p++) {
    /* ... */
}

Di iterasi terakhir p menjadi arr + n, perbandingannya gagal, dan loop selesai, tanpa pernah membaca posisi itu.

Meski begitu, ada dua hal yang tetap undefined. Membentuk pointer dua posisi setelah akhir, atau satu posisi sebelum awal, adalah undefined behavior meskipun kamu tidak pernah melakukan dereference:

int *bad1 = arr + n + 1;   // undefined - too far past
int *bad2 = arr - 1;       // undefined - before the beginning

Yang kedua penting dalam praktik: loop mundur yang ditulis for (int *p = arr + n - 1; p >= arr; p--) menghitung arr - 1 pada decrement terakhirnya. Kode itu bekerja di semua compiler yang umum, tapi secara formal tetap undefined. Loop mundur yang bersih menghindarinya:

#include <stdio.h>

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

    // walks backward without ever stepping before the start
    for (int *p = arr + n; p != arr; ) {
        p--;
        printf("%d ", *p);
    }
    printf("\n");

    return 0;
}

Pointer void dan aritmetika yang tidak bisa dilakukan

void * menyimpan alamat tanpa tipe, dan dengan cara itulah malloc dan qsort tetap generik. Karena tidak ada ukuran elemen, aritmetika pointer pada void * tidak diizinkan oleh standar: cast dulu ke tipe yang konkret (atau ke char * untuk pekerjaan tingkat byte).

void *v = buffer;
// v + 1;              // not standard C - no size to scale by
char *b = v;
b + 1;                 // fine - one byte forward

GCC dan Clang menerima aritmetika void * sebagai ekstensi yang memperlakukannya seperti char *, jadi kode yang bergantung padanya tetap bisa dikompilasi sampai suatu hari di-build di tempat yang lebih ketat. Kompilasi dengan -std=c17 -pedantic kalau kamu ingin diberi tahu.

Apa yang kamu dapatkan dari sini

Aritmetika pointer bukan trik optimasi yang sesekali kamu pakai: ini mekanisme di balik pengindeksan array, penanganan string, dan setiap penelusuran buffer di library standar. strlen adalah pointer yang dimajukan sampai '\0' penutup lalu dikurangkan dari awalnya. memcpy adalah dua pointer yang melangkah bersamaan.

Selanjutnya, lihat bagaimana kesetaraan array dan pointer sebenarnya bekerja, termasuk jebakan sizeof yang menangkap semua orang saat pertama kali mengirim array ke fungsi: pointer dan array.