İteratörler

Coddy'nin C++ Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası — ders 72 / 104.

Yineleyiciler (Iterators), kapsayıcılar ve algoritmalar arasında bir köprü görevi gören nesnelerdir. Bir kapsayıcının verilerini dahili olarak nasıl sakladığına bakılmaksızın, herhangi bir kapsayıcıdaki elemanlara erişmek için standart bir yol sağlarlar. Bir yineleyiciyi, bir kapsayıcı içinde nasıl hareket edeceğini bilen genelleştirilmiş bir işaretçi olarak düşünebilirsiniz.

Her STL konteyneri begin() ve end() metotlarını sağlar. begin() yineleyicisi ilk öğeyi işaret ederken, end() son öğeden bir sonrasını -nerede durulacağını belirleyen bir nöbetçi değeri- işaret eder:

#include <vector>
#include <iostream>

int main() {
    std::vector<int> nums = {10, 20, 30};
    
    for (std::vector<int>::iterator it = nums.begin(); it != nums.end(); ++it) {
        std::cout << *it << " ";  // Değeri almak için dereference yapın
    }
    // Çıktı: 10 20 30
}

auto anahtar kelimesi, iterator bildirimlerini önemli ölçüde basitleştirir:

for (auto it = nums.begin(); it != nums.end(); ++it) {
    *it *= 2;  // Elemanları iterator aracılığıyla değiştirin
}
// nums artık {20, 40, 60}

Yineleyiciler, yeteneklerine bağlı olarak farklı kategorilerde gelirler. Rastgele erişim yineleyicileri (vector yapısındakiler gibi), it + 3 veya it1 - it2 gibi aritmetik işlemleri desteklerler.

Çift yönlü yineleyiciler (list, map yapılarından), ++ ve -- ile ileri ve geri hareket edebilir. İleri yönlü yineleyiciler ise yalnızca tek bir yönde hareket edebilir.

Tersine gezinme için rbegin() ve rend() kullanın:

for (auto rit = nums.rbegin(); rit != nums.rend(); ++rit) {
    std::cout << *rit << " ";  // Ters sırada yazdırır
}

Görev

Kolay

Öğe koleksiyonlarını dolaşmak ve işlemek için yineleyicileri (iterators) kullanan bir envanter takip sistemi oluşturalım. Veriler arasında çeşitli şekillerde gezinmek için farklı yineleyici türlerini kullanma pratiği yapacaksınız.

Kodunuzu iki dosya halinde düzenleyeceksiniz:

Inventory.h: Bir std::vector<int> içinde saklanan öğe miktarlarından oluşan bir koleksiyonu yöneten bir Inventory sınıfı tanımlayın.
Sınıfınız şu metotları sağlamalıdır:
- addItem(int quantity) — envantere bir öğe miktarı ekler
- printForward() — tüm miktarları aralarında boşluk bırakarak yazdırmak için begin() ve end() ile yineleyicileri kullanır ve ardından bir yeni satır ekler
- printReverse() — tüm miktarları ters sırada, aralarında boşluk bırakarak yazdırmak için rbegin() ve rend() ile ters yineleyicileri (reverse iterators) kullanır ve ardından bir yeni satır ekler
- doubleAll() — vektörü dolaşmak ve her bir miktarı olduğu yerde iki katına çıkarmak için yineleyicileri kullanır
- getTotal() — tüm miktarların toplamını hesaplamak ve döndürmek için yineleyicileri kullanır
Kodun temiz kalması için yineleyici bildirimlerinizde auto anahtar kelimesini kullanın.
main.cpp: Öğe miktarlarını temsil eden (her biri ayrı bir satırda) dört tam sayı girdisi okuyun.
Bir Inventory nesnesi oluşturun ve dört miktarın tümünü ekleyin. Ardından yineleyici kullanımını şu şekilde gösterin:
1. Forward: yazdırın ve ardından printForward() metodunu çağırın
2. Reverse: yazdırın ve ardından printReverse() metodunu çağırın
3. getTotal() kullanarak Total: <sum> yazdırın
4. Miktarları değiştirmek için doubleAll() metodunu çağırın
5. After doubling: yazdırın ve ardından printForward() metodunu çağırın
6. getTotal() kullanarak New total: <sum> yazdırın

Örneğin, 10, 25, 15 ve 30 girdileriyle:

Forward: 10 25 15 30 
Reverse: 30 15 25 10 
Total: 80
After doubling: 20 50 30 60 
New total: 160

Bu zorluk, hem yineleyiciler aracılığıyla öğeleri okuma (yazdırma ve toplama için) hem de yineleyiciler aracılığıyla öğeleri değiştirme (iki katına çıkarma için) pratiği yapmanızı sağlar. Ayrıca, ters yineleyicilerin herhangi bir dizin (index) işlemi yapmadan geriye doğru dolaşmayı nasıl kolaylaştırdığını göreceksiniz.

Kopya kağıdı

İteratörler, konteynerlerdeki elemanlara erişmek için tek tip bir yol sağlayan nesnelerdir. Bir konteyner içinde nasıl hareket edileceğini bilen genelleştirilmiş işaretçiler gibi davranırlar.

Her STL konteyneri begin() ve end() metotlarını sağlar. begin() iteratörü ilk elemanı işaret ederken, end() son elemandan bir sonrasını işaret eder:

std::vector<int> nums = {10, 20, 30};

for (std::vector<int>::iterator it = nums.begin(); it != nums.end(); ++it) {
    std::cout << *it << " ";  // Değeri almak için dereference işlemi
}

İteratör bildirimlerini basitleştirmek için auto anahtar kelimesini kullanın:

for (auto it = nums.begin(); it != nums.end(); ++it) {
    *it *= 2;  // İteratör aracılığıyla elemanları değiştir
}

Yeteneklerine göre iteratör kategorileri:

Rastgele erişim iteratörleri (örneğin, vector) it + 3 veya it1 - it2 gibi aritmetik işlemleri destekler
Çift yönlü iteratörler (örneğin, list, map) ++ ve -- ile ileri ve geri hareket edebilir
İleri yönlü iteratörler sadece tek yönde hareket edebilir

Ters yönde gezinmek için rbegin() ve rend() kullanın:

for (auto rit = nums.rbegin(); rit != nums.rend(); ++rit) {
    std::cout << *rit << " ";  // Ters sırada yazdırır
}

Kendin dene

#include <iostream>
#include "Inventory.h"

using namespace std;

int main() {
    // Dört tam sayı girdisi oku
    int q1, q2, q3, q4;
    cin >> q1;
    cin >> q2;
    cin >> q3;
    cin >> q4;

    // TODO: Bir Inventory nesnesi oluştur

    // TODO: Dört miktarın hepsini envantere ekle

    // TODO: "Forward: " yazdır ve ardından printForward() çağır

    // TODO: "Reverse: " yazdır ve ardından printReverse() çağır

    // TODO: "Total: " yazdır ve ardından getTotal() sonucunu yazdır

    // TODO: Miktarları değiştirmek için doubleAll() çağır

    // TODO: "After doubling: " yazdır ve ardından printForward() çağır

    // TODO: "New total: " yazdır ve ardından getTotal() sonucunu yazdır

    return 0;
}