C'de Göstericiler ve Diziler: Dönüşüm, arr[i] = *(arr+i) ve sizeof Tuzağı

Diziler ve göstericiler C'de, çoğu zaman aynı şekilde davranan farklı şeylerdir. O "çoğu zaman", konuyu kaygan kılan şeydir: bir diziye gösterici gibi davranan kod genellikle çalışır, ta ki farkın önemli olduğu iki yerden birine düşüp cevabın sessizce yanlış olduğu güne dek.

Bu sayfa çizgiyi kesin biçimde çiziyor.

Dizi Dönüşümü: Her Şeyin Ardındaki Tek Kural

Hemen her ifadede bir dizi adı, otomatik olarak ilk elemanına bir göstericiye dönüştürülür. Buna dönüşüm (decay) denir. arr, int * tipiyle &arr[0] olur.

#include <stdio.h>

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

    printf("arr      = %p\n", (void *)arr);       // &arr[0]'a donusur
    printf("&arr[0]  = %p\n", (void *)&arr[0]);   // ayni adres
    printf("*arr     = %d\n", *arr);              // 10, ilk eleman

    int *p = arr;                                  // & gerekmez - donusum yapar
    printf("*p       = %d\n", *p);

    return 0;
}

Dizi adı ile ilk elemanının adresi aynı şekilde yazdırılır. İş başındaki dönüşüm budur ve bir diziyi bir göstericiye & olmadan atayabilmenizin sebebidir.

Dönüşümün gerçekleşmediği tam olarak üç yer vardır: sizeof'un işleneni olarak, &'in işleneni olarak ve bir karakter dizisine bir metin sabitinden ilk değer verirken. Diğer her yerde dönüşümü varsayın.

arr[i] Harfi Harfine *(arr + i)'dir

C standardı indeks operatörünü gösterici aritmetiği cinsinden tanımlar: a[b], *(a + b) demektir. İndeksleme ayrı bir özellik değildir - bir kısaltmadır.

#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  (bir gosterici de indekslenebilir)\n", p[2]);
    printf("2[arr] = %d  (gecerli, cunku toplama degismelidir)\n", 2[arr]);

    return 0;
}

Bundan iki sonuç çıkar. Birincisi, bir gösterici indekslenebilir: p[2], *(p + 2)'dir; gösterici alan fonksiyonların tanıdık arr[i] söz dizimini hâlâ kullanabilmesinin sebebi budur. İkincisi, 2[arr] derlenir - *(2 + arr), *(arr + 2) ile aynı adrestir. Bunu bir sınav dışında kimse yazmaz, ama indekslemenin "gerçekten" gösterici aritmetiği olup olmadığı sorusunu çözer.

Bir Fonksiyona Dizi Geçirmek

Dönüşüm yüzünden bir fonksiyon asla bir dizi almaz. Bir gösterici alır.

#include <stdio.h>

// bu uc bildirim derleyici icin OZDESTIR
int sum_a(int arr[], int n);
int sum_b(int arr[100], int n);   // 100 tamamen yok sayilir
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("toplam = %d\n", sum_c(data, n));

    // bir dilimde de calisir - gosterici sadece bir baslangic konumudur
    printf("kuyruk = %d\n", sum_c(data + 3, 3));

    return 0;
}

O örnekten çıkarılmaya değer üç şey.

int arr[100]'deki boyut belgelemedir, başka bir şey değil. Derleyici parametreyi int *arr olarak yeniden yazar ve 100 tane bir şey geçirdiğinizi asla denetlemez.

Uzunluk ayrı yolculuk etmelidir. Fonksiyonun bir adresi vardır ve verinin ne kadar uzandığı hakkında hiçbir fikri yoktur. Neredeyse her dizi alan C fonksiyonunun bir sayı almasının sebebi budur: memcpy(dst, src, n), fread(ptr, size, count, f), qsort(base, nmemb, size, cmp). Metinler yalnızca kendi son işaretlerini, '\0''ı, taşıdıkları için istisnadır.

Bir gösterici geçirmek ucuzdur ve veri paylaşılır. Dizinin kopyası çıkarılmaz, dolayısıyla fonksiyon çağıranın elemanlarını değiştirebilir - çoğu zaman tam olarak istediğiniz budur:

#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: degistirmeyecegine soz verir
    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);      // cagiranin dizisi gercekten degisti

    return 0;
}

Salt okunur parametreleri print_all'ın yaptığı gibi const int * işaretleyin. Bu niyeti belgeler ve derleyicinin kazara bir yazmayı yakalamasını sağlar.

sizeof Tuzağı

İşte her C programcısını bir kez yakalayan hata. sizeof, dönüşümün gerçekleşmediği iki yerden biridir - dolayısıyla dizinin bildirildiği yerde gerçek dizi boyutunu, dizinin dönüştüğü her yerde bir göstericinin boyutunu verir.

#include <stdio.h>

void inspect(int arr[]) {
    printf("fonksiyon icinde: sizeof(arr) = %zu\n", sizeof arr);
    printf("fonksiyon icinde: hesaplanan uzunluk = %zu  <-- YANLIS\n",
           sizeof arr / sizeof arr[0]);
}

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

    printf("main icinde: sizeof(data) = %zu\n", sizeof data);
    printf("main icinde: uzunluk = %zu  <-- dogru\n",
           sizeof data / sizeof data[0]);

    inspect(data);
    return 0;
}

main içinde sizeof data 40 bayttır ve uzunluk 10 hesaplanır. inspect içinde sizeof arr bir göstericinin boyutudur - 64 bitlik bir makinede 8 - ve "uzunluk" 2 çıkar. Kod özdeş görünür ve sessizce yanlıştır.

Bundan çıkan kural: bir dizinin uzunluğunu yalnızca dizinin bildirildiği kapsamda hesaplayın ve oradan aktarın.

Bir Dizinin &'i Aynı Tip Değildir

Dönüşümün gerçekleşmediği diğer yer & operatörüdür. &arr, ilk elemanına değil tüm diziye bir göstericidir. İkisi de aynı adresi tutar; fark "bir ekle"nin ne anlama geldiğidir.

#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));      // 4 bayt adimlar (bir int)
    printf("&arr     = %p   &arr + 1 = %p\n",
           (void *)&arr, (void *)(&arr + 1));    // 20 bayt adimlar (tum dizi)

    return 0;
}

Aynı başlangıç adresi, farklı adım. arr'ın tipi int *'dır ve bir eleman adımlar; &arr'ın tipi int (*)[5]'tir ve tüm diziyi adımlar. Bu, bir 2B dizinin bir satırını geçirmeyi çalıştıran mekanizmadır ve çok boyutlu diziler sayfasında ele alınıyor.

Diziye Gösterici ile Gösterici Dizisi

Birbirine benzeyen ve zıt anlamlara gelen iki bildirim:

int *p[5];     // int'e 5 göstericiden oluşan dizi
int (*q)[5];   // 5 int'lik bir diziye gösterici

[]'nin önceliği *'dan yüksektir, dolayısıyla int *p[5], "p bir dizidir, göstericilerden" olarak ayrıştırılır. int (*q)[5]'teki parantezler *'ın önce bağlanmasını zorlar: "q bir göstericidir, bir diziye".

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

 p[0] -> [ int ]               q -> [ int | int | int | int | int ]
 p[1] -> [ int ]                     5 elemanlik bitisik tek blok
 p[2] -> [ int ]
 p[3] -> [ int ]
 p[4] -> [ int ]
 bes ayri adres

Gösterici dizisi yaygın olanıdır ve onu zaten kullandınız: char *argv[], her komut satırı argümanı için bir tane olmak üzere metinlere göstericilerden oluşan bir dizidir. Ayrıca yer harcamadan farklı uzunluklarda metinlerden bir liste tutma yolunuzdur.

#include <stdio.h>

int main(void) {
    // gosterici dizisi: her girdi kendi uzunlugunda bir metni gosterir
    const char *days[] = {"Pazartesi", "Sali", "Carsamba"};
    int n = sizeof days / sizeof days[0];

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

    // 5 int'lik bir diziye gosterici
    int block[5] = {1, 2, 3, 4, 5};
    int (*q)[5] = &block;

    printf("q uzerinden: %d %d\n", (*q)[0], (*q)[4]);
    printf("sizeof(*q) = %zu bayt (tum dizi)\n", sizeof *q);

    return 0;
}

(*q)[0]'a dikkat edin: diziyi almak için göstericiyi dereferans edin, sonra indeksleyin. Parantezler yine aynı öncelik sebebiyle zorunludur.

Dizilerle Göstericilerin Gerçekten Ayrıştığı Yerler

Bu kısa tabloyu aklınızda tutun, kafa karışıklığı yok olur:

Bir dizi adı, adres tutan bir değişken değildir - depolamanın ta kendisidir ve adres istendiğinde hesaplanır. Ona atama yapamamanızın sebebi budur.