C'de Diziler: Tanımlama, İlk Değer Verme ve Üzerlerinde Dolaşma

Dizi, aynı türden elemanların bellekte arka arkaya dizilmiş, sabit boyutlu bir bloğudur. Bu bitişik yerleşim hikâyenin tamamıdır: indekslemenin neden anlık olduğunu, dizilerle göstericilerin neden bu kadar yakın akraba olduğunu ve C'nin size neden sıfırıncı elemanın adresini verip gerisini aritmetikle bulmanıza izin verdiğini açıklar.

Bir Dizi Tanımlamak

Eleman tipi, isim ve köşeli parantez içinde bir boyut:

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

Boyut eleman sayısıdır ve dizinin tanımlandığı yerde biliniyor olmalıdır - genellikle bir sabit değer ya da #define'lanmış bir sabit. Bellek hemen ayrılır; sonradan bir tahsis yapılmaz.

Yeni tanımlanmış yerel bir dizi sıfır değil çöp içerir:

#include <stdio.h>

int main(void) {
    int uninitialized[5];        // icerik belirsizdir
    int zeroed[5] = {0};         // her eleman 0

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

    printf("\nilk degersiz: ");
    for (int i = 0; i < 5; i++) printf("%d ", uninitialized[i]);
    printf("   <-- o bellekte ne varsa\n");

    return 0;
}

İkinci satır sıfırlar yazdırabilir, kocaman sayılar yazdırabilir ve çalıştırmalar arasında ya da hata ayıklama ile yayın derlemesi arasında farklılık gösterebilir. Bu değerleri okumak tanımsız davranıştır; okumadan önce ilk değeri verin.

İlk Değer Verme

Hepsi işe yarar birkaç biçim:

#include <stdio.h>

int main(void) {
    int a[5] = {10, 20, 30, 40, 50};   // tam liste
    int b[5] = {1, 2};                 // gerisi sifirla dolar: 1 2 0 0 0
    int c[5] = {0};                    // dizinin tamami sifir
    int d[]  = {7, 8, 9};              // boyut cikarilir: 3 eleman
    int e[5] = {[4] = 99, [0] = 1};    // belirtilmis ilk degerler (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("  (boyut %d olarak cikarildi)", n);
    printf("\ne: "); for (int i = 0; i < 5; i++) printf("%d ", e[i]);
    printf("\n");

    return 0;
}

Akılda tutulması gereken {0} deyimidir: listelemediğiniz tüm elemanlara sıfır atanır, dolayısıyla tek bir sıfır tüm diziyi sıfırlar. Belirtilmiş ilk değerler ([4] = 99) belirli konumları ayarlayıp gerisini sıfırda bırakmanıza olanak tanır; çoğu boş olan arama tabloları için kullanışlıdır.

Sonradan bir diziye atama yapamazsınız:

int a[3] = {1, 2, 3};
int b[3];
b = a;                    // hata: bir diziye atama yapılamaz
memcpy(b, a, sizeof a);   // bir diziyi böyle kopyalarsınız

İndeksleme Sıfırdan Başlar

İlk eleman arr[0], sonuncusu arr[n-1]'dir. arr[n] diye bir şey yoktur.

#include <stdio.h>

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

    printf("ilk    scores[0] = %d\n", scores[0]);
    printf("ucuncu scores[2] = %d\n", scores[2]);
    printf("son    scores[4] = %d\n", scores[4]);

    scores[1] = 95;                       // bir elemana yaz
    printf("guncellemeden sonra scores[1] = %d\n", scores[1]);

    printf("\nadresler (esit araliklara dikkat):\n");
    for (int i = 0; i < 5; i++) {
        printf("  scores[%d] adresi %p\n", i, (void *)&scores[i]);
    }

    return 0;
}

Bu son döngüyü çalıştırın ve adreslere bakın: her biri bir öncekinden tam olarak sizeof(int) bayt sonradır. Elemanlar gerçekten uç uca dizilmiştir:

 indeks     0         1         2         3         4
         +--------+--------+--------+--------+--------+
 deger   |   88   |   95   |   75   |   60   |  100   |
         +--------+--------+--------+--------+--------+
 offset   +0       +4       +8       +12      +16      bayt
          ^
          &scores[0], `scores` de buna dönüşür

Sıfır tabanlı indeksleme keyfî bir seçim değildir - indeksi başlangıçtan itibaren bir offset hâline getirir ki adres aritmetiğinin ihtiyacı tam olarak budur. scores[i], *(scores + i) olarak tanımlanır; bkz. göstericiler ve diziler.

Uzunluğu Bulmak

C, bir dizinin uzunluğunu çalışma zamanında hiçbir yerde saklamaz, ama derleyici bilir ve sizeof size erişim verir:

#include <stdio.h>

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

    printf("toplam bayt      = %zu\n", sizeof prices);
    printf("eleman basi bayt = %zu\n", sizeof prices[0]);
    printf("uzunluk          = %zu\n", sizeof prices / sizeof prices[0]);

    return 0;
}

sizeof(arr) / sizeof(arr[0]) deyimdir. Sabit yazılmış bir sizeof(double) yerine arr[0]'a bölmek, eleman tipini değiştirdiğinizde satırın çalışmaya devam etmesi demektir.

Tuzak: bu yalnızca dizinin tanımlandığı yerde çalışır. Diziyi bir fonksiyona geçirin, parametre bir göstericidir, dolayısıyla sizeof bunun yerine göstericiyi ölçer - tipik olarak 8 bayt, yani "uzunluk" 1 ya da 2 çıkar. C'de dizi alan her fonksiyonun aynı zamanda bir sayı alması bu yüzdendir:

#include <stdio.h>

int sum(const int *arr, int n) {       // uzunluk disaridan gelmeli
    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];   // BURADA hesaplandi, dogru oldugu yerde

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

    return 0;
}

Bir Dizi Üzerinde Döngü

Standart biçim, 0'dan başlayan ve i < n olduğu sürece dönen bir for döngüsüdür:

#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("olcumler: ");
    for (int i = 0; i < n; i++) printf("%d ", temps[i]);

    printf("\nortalama: %.1f\n", (double)total / n);
    printf("en sicak: %d\n", hottest);
    printf("en soguk: %d\n", coldest);

    return 0;
}

i <= n değil, i < n olduğuna dikkat edin. n elemanla geçerli indeksler 0 ile n - 1 arasındadır, dolayısıyla <= fazladan bir geçiş yapar ve sonun ötesini okur. hottest ile coldest'a 0 yerine temps[0]'dan başlangıç değeri vermek de kopyalamaya değer diğer alışkanlıktır - bir maksimumu sıfırdan başlatmak, tamamı negatif veride sessizce bozulur.

Sınır Dışına Çıkmak Tanımsız Davranıştır

C'nin başka dillerden gelenleri şaşırtan kısmı budur. Sınır kontrolü yoktur. Ne derleme zamanında ne de çalışma zamanında. Beş elemanlı bir dizide arr[10] bir hata değildir - derleyicinin hiç yorum yapmadan gerçekleştirdiği bir adres hesabıdır.

int arr[5] = {1, 2, 3, 4, 5};
arr[7] = 99;     // dizinin sonundan 8 bayt öteye yazar
int x = arr[-1]; // başlangıcın öncesini okur

Bundan sonra olan tanımsız davranıştır ve belirtileri can sıkıcı biçimde çeşitlidir:

• çalışıyor gibi görünür, çünkü isabet ettiği bellek kullanılmıyordu;
• görünür bir sebep olmadan başka bir değişken değişir;
• program bir segmentation fault ile, muhtemelen çok sonra çöker;
• davranış -O0 ile -O2 arasında farklılık gösterir.

"Çalışıyor gibi görünmek" tehlikeli olanıdır, çünkü hata ürüne kadar gider. Üç savunma:

1. i < n ile döngü kurun. Taşmaların çoğu bir döngü koşulundaki bir-eksik/bir-fazla hatalarıdır.
2. Girdiden gelen indeksleri doğrulayın.

#include <stdio.h>

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

    int requests[4] = {2, 5, -1, 4};    // bunlarin ikisi aralik disinda

    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("indeks %d reddedildi (gecerli aralik 0..%d)\n", idx, n - 1);
        }
    }

    return 0;
}

3. Geliştirirken bir denetleyiciyle (sanitizer) derleyin. gcc -fsanitize=address -g prog.c taşmaların çoğunu, dosyayı, satırı ve ilgili diziyi adlandıran anlık bir rapora dönüştürür.

Diğer Türlerden Diziler

Aynı söz dizimi, yapılar dahil her eleman tipi için çalışır:

#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);
    }

    // '\0' ile biten bir char dizisi bir metindir
    char word[6] = "hello";        // 5 karakter arti sonlandirici
    printf("\nword = %s (%zu bayt depolama)\n", word, sizeof word);

    return 0;
}

char word[6] = "hello"; satırı biraz durup düşünmeye değer: bir C metni, son anlamlı baytı '\0' olan bir char dizisinden ibarettir. Dizinin beş harf için altı yuvaya ihtiyaç duymasının sebebi o sonlandırıcıdır.

Kısaca Değişken Uzunluklu Diziler

C99, boyutu bir çalışma zamanı değeri olan dizilere izin verir:

int n = get_count();
int buffer[n];        // değişken uzunluklu bir dizi

İki uyarı. Boyut, dizi oluşturulduktan sonra sabittir, dolayısıyla bir VLA büyüyebilen bir liste değildir. Ve bellek yığından (stack) gelir, dolayısıyla büyük ya da saldırgan kontrolündeki bir n onu taşırıp programı çökertebilir - Linux çekirdeği dahil pek çok projenin VLA'ları tamamen yasaklamasının sebebi budur. Ayrıca C11 gerçekleştirimleri için desteklenmesi isteğe bağlıdır.

Boyut gerçekten çalışma zamanına kadar bilinmiyorsa, bunun yerine tahsis edin:

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

int main(void) {
    int n = 6;                              // bunun girdiden geldigini varsayin

    int *arr = malloc(n * sizeof *arr);     // yigin degil, obek
    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]);              // indeksleme tipatip ayni calisir
    }
    printf("\n");

    free(arr);
    return 0;
}

arr[i]'nin, arr bir dizi de olsa tahsis edilmiş belleğe gösterici de olsa aynı şekilde okunduğuna dikkat edin - indeksleme söz dizimi umursamaz. Tüm ayrıntılar dinamik bellek sayfasında.