Çalıştırılabilir C Dokümanları: Çok Boyutlu Diziler

Q: C'de bir 2B dizi nasıl tanımlanır?

Köşeli parantez içinde iki boyut verin: int grid[3][4];, 4 sütunluk 3 satır - toplam 12 int - tanımlar. Bunu "her biri 4 int'lik bir dizi olan 3 şeyden oluşan bir dizi" diye okuyun; C onu tam olarak böyle saklar.

Q: C'de bir fonksiyona 2B dizi nasıl geçirilir?

Parametre sütun sayısını bildirmelidir: void print(int grid[][4], int rows) ya da eşdeğer olarak void print(int (*grid)[4], int rows). Satır sayısı atlanabilir, çünkü dizi bir satıra göstericiye dönüşür - ama sütun boyutu olmadan derleyici bir satırın nerede başladığını hesaplayamaz.

Q: Bir 2B diziye tümü sıfır olacak şekilde ilk değer verilebilir mi?

Evet: int grid[3][4] = {0}; her elemanı sıfırlar, çünkü listelemediğiniz her elemana sıfır atanır. int grid[3][4] = {{1, 2}};, 0. satırın ilk iki girdisini ayarlar ve diğer onunu sıfırda bırakır.

Çok boyutlu dizi, elemanları da dizi olan bir dizidir. int grid[3][4]; özel bir ızgara tipi değildir - her biri dört int'lik bir dizi olan, arka arkaya saklanmış üç elemandır. Bu anlaşıldığında konunun gerisi takip eder: yerleşim, indeksleme aritmetiği ve onları fonksiyonlara geçirmekle ilgili başka türlü şaşırtıcı olan kural.

İki boyut neredeyse her pratik kullanımı kapsar - ızgaralar, tablolar, matrisler, oyun tahtaları, görüntüler - dolayısıyla bu sayfa onunla çalışıyor.

Tanımlamak ve İlk Değer Vermek

int grid[3][4];        // 3 satır, 4 sütun - 12 int

İlk sayı kaç satır, ikincisi kaç sütun olduğudur. İlk değerler düz ya da iç süslü parantezlerle yazılabilir; süslü parantezleri kullanmaya değer, çünkü biçimi gösterirler.

#include <stdio.h>

int main(void) {
    int a[2][3] = {{1, 2, 3}, {4, 5, 6}};   // satir satir - en acik
    int b[2][3] = {1, 2, 3, 4, 5, 6};       // duz - ayni sonuc
    int c[2][3] = {{1, 2}, {4}};            // kismi satirlar: gerisi sifir
    int d[2][3] = {0};                      // her eleman sifir
    int e[][3]  = {{1, 2, 3}, {4, 5, 6}};   // satirlar cikarilir, sutunlar zorunlu

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

    return 0;
}

int e[][3] biçimi önemlidir: satır sayısını boş bırakıp ilk değerin karar vermesine izin verebilirsiniz, ama sütun sayısı asla isteğe bağlı değildir. Sonraki bölüm nedenini açıklıyor.

Satır-Öncelikli Yerleşim

C bir 2B diziyi satır-öncelikli sırada saklar: 0. satırın tamamı, sonra 1. satırın tamamı vb., kesintisiz tek bir bellek bloğunda. Perde arkasında satır göstericilerinden oluşan bir dizi yoktur.

int grid[3][4] = {{ 1, 2, 3, 4},
                  { 5, 6, 7, 8},
                  { 9,10,11,12}};

zihninizde canlandirdiginiz         bellekte gercekte durdugu
+----+----+----+----+
|  1 |  2 |  3 |  4 |   satir 0  +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+            | 1| 2| 3| 4| 5| 6| 7| 8| 9|10|11|12|
|  5 |  6 |  7 |  8 |   satir 1  +--+--+--+--+--+--+--+--+--+--+--+--+
+----+----+----+----+             \_ satir 0 _/\_ satir 1 _/\_ satir 2 _/
|  9 | 10 | 11 | 12 |   satir 2
+----+----+----+----+            grid[i][j], i*4 + j eleman indeksindedir

O formül, i * sutun + j, mekanizmanın tamamıdır - ve derleyicinin bir şeyi indekslemek için neden sütun sayısını bilmesi gerektiğinin sebebidir. Satır sayısı hesaba hiç girmez.

Yerleşimi adresleri yazdırarak doğrudan görebilirsiniz:

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    printf("eleman adresleri, bellek sirasinda:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("grid[%d][%d] = %2d adres %p\n", i, j, grid[i][j], (void *)&grid[i][j]);
        }
    }

    // ayni blok, 12 int'lik tek duz dizi olarak okundu
    printf("\nduzlestirilmis: ");
    int *flat = &grid[0][0];
    for (int k = 0; k < 12; k++) {
        printf("%d ", flat[k]);
    }
    printf("\n");

    return 0;
}

Adresler, bir satırın bitip diğerinin başladığı yer dahil, boşluksuz sizeof(int) kadar tırmanır. Düzleştirilmiş döngü bunu kanıtlar - flat[k] on iki elemanın hepsini tek bir dizi olarak dolaşır.

Bu yerleşimin bilmeye değer bir başarım sonucu da vardır: önce satır sonra sütun döngüsü belleğe sırayla dokunur ki CPU önbelleği bunu sever. Döngü iç içeliğini, iç döngü bir sütundan aşağı inecek şekilde değiştirmek her seferinde bütün bir satır atlar ve büyük bir dizide birkaç kat yavaş çalışabilir.

İç İçe Döngüler

İki boyut iki for döngüsü ister: dıştaki satırı seçer, içteki o satırın sütunlarını tarar.

#include <stdio.h>

#define ROWS 3
#define COLS 4

int main(void) {
    int grid[ROWS][COLS];

    // bir carpim tablosuyla doldur
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            grid[i][j] = (i + 1) * (j + 1);
        }
    }

    // tablo olarak yazdir
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d", grid[i][j]);
        }
        printf("\n");
    }

    // satir toplamlari ve genel toplam
    int grand = 0;
    printf("\nsatir toplamlari: ");
    for (int i = 0; i < ROWS; i++) {
        int rowSum = 0;
        for (int j = 0; j < COLS; j++) {
            rowSum += grid[i][j];
        }
        grand += rowSum;
        printf("%d ", rowSum);
    }
    printf("\ngenel toplam: %d\n", grand);

    return 0;
}

Sayaçları ne anlama geldiklerine göre adlandırın (satırlar için i/row, sütunlar için j/col) ve sırayı tutarlı tutun - her yerde grid[row][col]. Tüm 2B dizi hatalarının yarısı, yer değiştirmiş bir indeks çiftidir.

#define'lanmış boyutlar da süs değildir: biçimi değiştirdiğinizde artık döngü sınırları ile bildirim birbirinden kopamaz.

Bir Fonksiyona 2B Dizi Geçirmek

İşte herkesi tökezleten kural: fonksiyonun parametresi sütun sayısını bildirmelidir.

#include <stdio.h>

#define COLS 4

// sutun boyutu zorunlu; satir sayisi ayri bir arguman olarak gelir
void print_grid(int grid[][COLS], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d", grid[i][j]);
        }
        printf("\n");
    }
}

// tipatip ayni parametre, gercekte oldugu gosterici olarak yazilmis
void scale_grid(int (*grid)[COLS], int rows, int factor) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            grid[i][j] *= factor;
        }
    }
}

int main(void) {
    int grid[3][COLS] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    print_grid(grid, 3);
    scale_grid(grid, 3, 10);
    printf("\nolceklendikten sonra:\n");
    print_grid(grid, 3);

    return 0;
}

Sebep dönüşümdür. grid'i geçirmek onu ilk elemanına bir göstericiye dönüştürür - ve elemanları satırlardır, dolayısıyla tip int (*)[4]'tür: 4 int'lik bir diziye gösterici. grid[i][j]'nin bir anlam ifade etmesi için derleyicinin bir satırın ne kadar uzun olduğunu bilmesi gerekir ve o 4'tür. Satır sayısı tipte gerçekten yoktur; ayrı bir argüman olarak yolculuk etmesinin sebebi budur.

int (*grid)[COLS] ile int grid[][COLS]'un iki farklı şekilde yazılmış aynı parametre olduğuna dikkat edin - parantezler zorunludur, çünkü int *grid[COLS] bunun yerine bir gösterici dizisi olurdu. Bu ayrım göstericiler ve diziler sayfasında ele alınıyor.

Sütun sayısı yalnızca çalışma zamanında biliniyorsa, C99'un değişken değiştirilmiş parametreleri onu önce geçirmenizi sağlar:

void print_any(int rows, int cols, int grid[rows][cols]);

rows ve cols, onları kullanan dizi parametresinden önce bildirilmelidir. Bunun mevcut olmadığı yerlerde yaygın alternatif, düz bir 1B dizi artı elle indeks aritmetiğidir:

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

// duz bir blogu satir x sutun say ve aritmetigi kendin yap
void print_flat(const int *data, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%4d", data[i * cols + j]);
        }
        printf("\n");
    }
}

int main(void) {
    int rows = 2, cols = 5;

    int *data = malloc((size_t)rows * cols * sizeof *data);
    if (data == NULL) return 1;

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            data[i * cols + j] = i * 10 + j;
        }
    }

    print_flat(data, rows, cols);
    free(data);
    return 0;
}

data[i * cols + j], sabit boyutlu durumda derleyicinin sizin için yazdığı şeyin tam olarak kendisidir. Bunu elle yapmak bir satıra mal olur ve çalışma zamanında kararlaştırılan her biçim için çalışır.

Bir Matris Örneği

Matris çarpımı tüm sayfayı bir araya getirir - satır-öncelikli depolama üzerinde üç iç içe döngü.

#include <stdio.h>

#define N 3

void multiply(const int a[][N], const int b[][N], int out[][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            int total = 0;
            for (int k = 0; k < N; k++) {
                total += a[i][k] * b[k][j];
            }
            out[i][j] = total;
        }
    }
}

void print_matrix(const char *label, const int m[][N]) {
    printf("%s\n", label);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%5d", m[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main(void) {
    int a[N][N] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int b[N][N] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
    int product[N][N] = {0};

    print_matrix("A:", a);
    print_matrix("B:", b);

    multiply(a, b, product);
    print_matrix("A x B:", product);

    // A'yi yerinde devrik yap
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {     // her cifti bir kez takas etmek icin i+1'den basla
            int temp = a[i][j];
            a[i][j] = a[j][i];
            a[j][i] = temp;
        }
    }
    print_matrix("A'nin devrigi:", a);

    return 0;
}

Kopyalamaya değer iki ayrıntı. İçteki k döngüsü a[i][k] ile b[k][j]'yi eşler - bir indeks bir satırı, diğeri bir sütunu dolaşır. Ve devrik, iç döngüsüne j = i + 1'den başlar: 0'dan başlamak her çifti iki kez takas eder ve matrisi değişmemiş bırakır.

Üç Boyut ve Ötesi

Kalıp genişler, fonksiyon parametreleriyle ilgili kural da öyle - ilki dışındaki her boyut bildirilmelidir.

#include <stdio.h>

int main(void) {
    // 2 katman, 3 satir, 4 sutun
    int cube[2][3][4] = {0};

    for (int z = 0; z < 2; z++) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                cube[z][i][j] = z * 100 + i * 10 + j;
            }
        }
    }

    for (int z = 0; z < 2; z++) {
        printf("katman %d:\n", z);
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                printf("%5d", cube[z][i][j]);
            }
            printf("\n");
        }
    }

    printf("\ntoplam eleman: %zu\n", sizeof cube / sizeof cube[0][0][0]);
    return 0;
}

Pratikte üç boyut, sabit boyutlu dizilerin hantallaşmaya başladığı yerdir ve kodun çoğu, hesaplanmış indeksli düz bir bloğa ya da her eksenin ne anlama geldiğini adlandıran bir yapı dizisine geçer.

Sık Yapılan Hatalar

grid[i, j] yazmak. Virgül operatörü i'yi değerlendirir, atar ve j ile indeksler. Derlenir. Yanlıştır. grid[i][j] kullanın.
İndeksleri yer değiştirmek. grid[col][row] yanlış yerden gerçek bir eleman okur, dolayısıyla bunu yakalayacak bir hata yoktur. Her yerde [row][col] sırasını koruyun.
Bir parametrede sütun boyutunu atlamak. void f(int grid[][]) derlenmez ve bu, derleyicinin sizi kurtarmasıdır.
Sınır dışına çıkmak. Her dizide olduğu gibi sınır denetimi yoktur. [3][4] bir ızgarada grid[0][5], sessizce grid[1][1]'i okur, çünkü yerleşim bitişiktir ve aritmetik umursamaz.

Sıkça Sorulan Sorular

C'de bir 2B dizi nasıl tanımlanır?

Köşeli parantez içinde iki boyut verin: int grid[3][4];, 4 sütunluk 3 satır - toplam 12 int - tanımlar. Bunu "her biri 4 int'lik bir dizi olan 3 şeyden oluşan bir dizi" diye okuyun; C onu tam olarak böyle saklar.

C'de bir 2B dizi bellekte nasıl saklanır?

Satır-öncelikli sırada: önce 0. satırın tüm elemanları, sonra 1. satırınkiler vb., tek bir bitişik blokta. grid[i][j], başlangıçtan i * sutun + j eleman kadar ötededir; derleyicinin ihtiyaç duyduğu sayının sütun sayısı olmasının sebebi budur.

C'de bir fonksiyona 2B dizi nasıl geçirilir?

Parametre sütun sayısını bildirmelidir: void print(int grid[][4], int rows) ya da eşdeğer olarak void print(int (*grid)[4], int rows). Satır sayısı atlanabilir, çünkü dizi bir satıra göstericiye dönüşür - ama sütun boyutu olmadan derleyici bir satırın nerede başladığını hesaplayamaz.

Bir 2B diziye tümü sıfır olacak şekilde ilk değer verilebilir mi?

Evet: int grid[3][4] = {0}; her elemanı sıfırlar, çünkü listelemediğiniz her elemana sıfır atanır. int grid[3][4] = {{1, 2}};, 0. satırın ilk iki girdisini ayarlar ve diğer onunu sıfırda bırakır.

İlgili kavramlar