C++ Diziler: Tanımlama, İndeksleme ve Sık Yapılan Hatalar

Sabit Boyutlu Bir Değer Dizisi

Bir dizi, aynı türden sabit sayıda değeri tutan bitişik bir bellek bloğudur. Tek bir int bir sayı saklarken, bir int dizisi bunlardan birçoğunu arka arkaya saklar ve her birine bir tamsayı indeksiyle ulaşılır.

Bir dizi tanımlamak için eleman tipini, bir adı ve köşeli parantez içinde bir boyut verirsiniz. Doldurmak için süslü parantezli bir liste ekleyin:

#include <iostream>
using namespace std;

int main() {
    int scores[4] = {90, 75, 100, 60};

    cout << "First score:  " << scores[0] << "\n";
    cout << "Fourth score: " << scores[3] << "\n";
}

İndeksleme sıfır tabanlıdır: ilk eleman scores[0]'dır ve boyutu 4 olan bir dizinin geçerli indeksleri 0'dan 3'e kadardır. Boyut, derleme zamanı sabiti olmalıdır; standart C++'ta int n = readInput(); int a[n]; yazamazsınız (bu, taşınabilir olmayan bir uzantıdır). Boyutun çalışma zamanında belirlenmesi gerektiğinde bunun yerine bir vector kullanın.

Dizileri İlklendirme

Bir diziyi doldurmanın birkaç yolu ve bilinmeye değer birkaç kısayol vardır:

#include <iostream>
using namespace std;

int main() {
    int a[3] = {1, 2, 3};   // açık
    int b[]  = {1, 2, 3};   // boyut listeden çıkarılır -> 3
    int c[5] = {1, 2};      // geri kalanı sıfırla ilklendirilir -> 1 2 0 0 0
    int d[4] = {};          // tümü sıfır

    cout << b[2] << " " << c[3] << " " << d[0] << "\n";
}

İçselleştirilmesi gereken püf nokta: boyuttan daha az ilklendirici verdiğinizde, geri kalanlar çöp olarak bırakılmaz, değerle ilklendirilir (sayısal türler için sıfır). Ancak hiç ilklendiricisi olmayan bir dizi — yerel olarak tanımlanmış int e[4]; — belirsiz değerler içerir ve atama yapmadan önce onları okumak tanımsız davranıştır.

Bir Dizi Üzerinde Döngü Kurma

Elemanlar bitişik saklandığı için bir diziyi düz bir indeks döngüsüyle dolaşırsınız. Sınırlar içinde kalmak için döngüyü, koda gömülü bir sayı yerine dizinin gerçek uzunluğuyla sürün:

#include <iostream>
using namespace std;

int main() {
    int scores[] = {90, 75, 100, 60};
    int n = sizeof(scores) / sizeof(scores[0]);

    int total = 0;
    for (int i = 0; i < n; i++) {
        total += scores[i];
    }

    cout << "Average: " << total / n << "\n";
}

sizeof(scores) tüm dizinin toplam bayt sayısıdır; bunu sizeof(scores[0])'a (bir elemanın boyutu) bölmek eleman sayısını verir. C++17'den beri daha temiz bir yazım var: std::size(scores). Bu daha okunaklıdır ve yanlışlıkla ona bir işaretçi verirseniz derlenmeyi reddeder. Yalnızca değerlere ihtiyacınız olduğunda daha da basiti: bir aralık tabanlı for indeks hesaplamasını tamamen atlar.

#include <iostream>
#include <iterator>   // std::size
using namespace std;

int main() {
    int scores[] = {90, 75, 100, 60};

    cout << "Count: " << size(scores) << "\n";

    for (int s : scores) cout << s << " ";
    cout << "\n";
}

Sınır Dışı Tuzağı

C++, arr[i] üzerinde hiçbir sınır denetimi yapmaz. Son elemanın ötesine indekslemek bir istisna fırlatmaz veya uyarı vermez; oraya ne denk geliyorsa o belleği okur ya da yazar. Bu, en sık görülen dizi hatasıdır ve klasik bir tanımsız davranış örneğidir:

int a[3] = {1, 2, 3};
a[3] = 99;          // OOPS - valid indices are 0..2, not 3
cout << a[5];       // garbage, crash, or corruption - undefined behavior

Bir-fazla (off-by-one) hatası genellikle bir döngü koşulunda gizlenir. i < n yerine i <= n yazmak bir adım fazla giderek var olmayan arr[n]'ye dokunur:

for (int i = 0; i <= n; i++)   // BUG: when i == n, arr[i] is out of bounds
    cout << arr[i];

Çözüm, önceki bölümdeki disiplindir: döngüyü asla <= ile değil i < size ile kurun ve boyutu, bir eleman eklediğinizde senkronizasyondan çıkan bir sabiti yeniden yazmak yerine diziden hesaplayın.

Dizi Bozulması: Gizli İşaretçi

C++'taki en aldatıcı dizi davranışı bozulmadır (decay): bir diziyi bir fonksiyona geçirdiğinizde, sessizce ilk elemanına bir işaretçiye dönüşür. Boyut bilgisi kaybolur, bu yüzden fonksiyonun içindeki sizeof diziyi değil işaretçiyi ölçer.

#include <iostream>
using namespace std;

void printSize(int arr[]) {
    // arr aslında int[4] değil, bir int*'dir
    cout << "inside:  " << sizeof(arr) << " bytes\n";   // bir işaretçinin boyutu
}

int main() {
    int data[4] = {1, 2, 3, 4};
    cout << "outside: " << sizeof(data) << " bytes\n";  // 16 (4 ints)
    printSize(data);
}

Fonksiyon parametreleri olarak int arr[] ile int* arr'ın aynı olduğuna dikkat edin; köşeli parantezler yalnızca süslemedir. Sayım kaybolduğu için, uzunluğu dizinin yanında kendiniz geçirmeniz gerekir:

int sum(const int* arr, int n) {
    int total = 0;
    for (int i = 0; i < n; i++) total += arr[i];
    return total;
}

Bu "bir işaretçi ile bir uzunluk geçir ve uyuşmaları için dua et" deseni, çoğu C++ kodunu kendi boyutunu taşıyan ve asla bozulmayan std::array ve std::vector'a iten sürtünmenin ta kendisidir.

Çok Boyutlu Diziler Üzerine Kısa Bir Not

Bir ızgara oluşturmak için köşeli parantezleri iç içe geçirebilirsiniz. Bir 2B dizi aslında bir diziler dizisidir ve bellekte satır satır yerleşir:

#include <iostream>
using namespace std;

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

    for (int r = 0; r < 2; r++) {
        for (int c = 0; c < 3; c++) {
            cout << grid[r][c] << " ";
        }
        cout << "\n";
    }
}

Onu grid[row][col] olarak indeksleyin. Aynı sınır ve bozulma uyarıları geçerlidir ve daha da kötüleşir, çünkü bir 2B diziyi bir fonksiyona geçirmek ilki dışındaki her boyutu açıkça yazmayı gerektirir (void f(int g[][3])). Küçük, sabit bir ızgaranın ötesindeki her şey için, bir vector'lardan oluşan vector çok daha az hataya açıktır.

Sıradaki: Vector

Ham diziler hızlı ve öngörülebilirdir, ancak sabit boyutları, sınır güvenliğinin olmaması ve işaretçiye bozulma davranışları onları günlük kod için hantal kılar. Sırada std::vector ile tanışacağız — talep üzerine büyüyen, kendi boyutunu hatırlayan ve doğrudan STL algoritmalarına bağlanan, yeniden boyutlandırılabilir bir dizi; size kendinizi vurmanın çok daha az yoluyla dizilerin sunduğunun neredeyse tamamını verir.