[] ve () Operatör Aşırı Yükleme

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

Alt simge operatörü ([]), sınıfınızın bir dizi gibi davranmasını sağlayarak öğelere indeksli erişim sunar. Fonksiyon çağırma operatörü (()), nesneleri functor'lar olarak bilinen çağrılabilir varlıklara dönüştürür.

İşte alt simge (subscript) operatörüne sahip basit bir dizi sarmalayıcı:

class IntArray {
    int* data;
    size_t size;
    
public:
    IntArray(size_t s) : size(s), data(new int[s]()) {}
    ~IntArray() { delete[] data; }
    
    int& operator[](size_t index) {
        return data[index];
    }
    
    const int& operator[](size_t index) const {
        return data[index];
    }
};

İki sürüm sunduğumuza dikkat edin: biri sabit olmayan (non-const) bir referans döndürür (değişikliğe izin verir) ve const sürümü const nesnelerle çalışır. Bu, okuma ve yazma için arr[0] = 5; yazmanıza olanak tanır.

Fonksiyon çağırma operatörü, fonksiyonlar gibi "çağrılabilen" nesneler oluşturur:

class Multiplier {
    int factor;
    
public:
    Multiplier(int f) : factor(f) {}
    
    int operator()(int value) const {
        return value * factor;
    }
};

Multiplier triple(3);
int result = triple(10);    // 30 döndürür

Functor'lar, normal fonksiyonların aksine çağrılar arasında durum koruyabildikleri için güçlüdürler. Yapılandırma değerlerini hatırlayan özelleştirilebilir davranışlara ihtiyaç duyduğunuz STL algoritmalarıyla yaygın olarak kullanılırlar.

Görev

Kolay

Hem indis (subscript) hem de fonksiyon çağırma (function call) operatörlerini birleştiren bir ScoreTracker sınıfı oluşturalım. Bu sınıf, oyuncuların puanlarını saklayacak ve [] kullanarak bunlara dizinle erişmenizi sağlayacak, aynı zamanda kendisine ilettiğiniz herhangi bir puana bonus çarpanı uygulayan bir funktor (functor) gibi davranacaktır.

Kodunuzu düzenlemek için iki dosya oluşturacaksınız:

ScoreTracker.h: Oyuncu puanlarından oluşan bir diziyi yöneten ve bonus uygulayabilen bir ScoreTracker sınıfı tanımlayın. Sınıfınız şunlara sahip olmalıdır:
- Puanları saklamak için dinamik olarak ayrılmış bir int* dizisi
- Puan sayısı için bir size_t üyesi
- Bonus çarpanı için bir double üyesi
- Boyutu ve bonus çarpanını alan, tüm puanları 0'a başlatan bir yapıcı (constructor)
- Dinamik belleği düzgün bir şekilde temizleyen bir yıkıcı (destructor)
- Puanlara dizinle erişmek için indis operatörü [] (hem const hem de non-const versiyonları)
- Bir int puanı alan ve bonus çarpanı ile çarpılmış puanı (bir int olarak) döndüren fonksiyon çağırma operatörü ()
- Puan sayısını döndüren bir getSize() metodu
Sabit olmayan (non-const) indis operatörü bir referans döndürür, böylece tracker[0] = 100; yazabilirsiniz. Sabit (const) versiyon, const nesneler için salt okunur erişim sağlar. Fonksiyon çağırma operatörü, nesnenin durumunu değiştirmediği için const olarak işaretlenmelidir.
main.cpp: Aşağıdaki girdileri okuyun (her biri ayrı bir satırda):
1. Oyuncu sayısı (boyut)
2. Bonus çarpanı (double olarak)
3. Her oyuncu için puanlar (her satıra bir tane, boyut kadar)
4. Bonusun uygulanacağı bir test puanı
Bir ScoreTracker oluşturun, her oyuncunun puanını saklamak için indis operatörünü kullanın, ardından tüm puanları görüntüleyin. Son olarak, bonus uygulanmış puanı hesaplamak için fonksiyon çağırma operatörünü kullanın.

Çıktı formatı:
```
Player 0: <score>
Player 1: <score>
...
Bonus applied to <test_score>: <result>
```

Örneğin, 3 oyuncu, 1.5 çarpanı, 100, 200, 150 puanları ve 80 test puanı ile:

Player 0: 100
Player 1: 200
Player 2: 150
Bonus applied to 80: 120

Girdi dönüşümü için std::stoi() ve std::stod() kullanın. Başlık dosyanızda header guard kullanmayı unutmayın.

Kopya kağıdı

Alt simge operatörü [], nesnelere diziler gibi erişilmesini sağlar. Fonksiyon çağırma operatörü () ise nesneleri fonksiyonlar gibi çağrılabilir hale getirir (functors).

Alt Simge Operatörü

Okuma/yazma erişimi için hem const hem de non-const versiyonlarını sağlayın:

class IntArray {
    int* data;
    size_t size;
    
public:
    IntArray(size_t s) : size(s), data(new int[s]()) {}
    ~IntArray() { delete[] data; }
    
    // Non-const version: allows modification
    int& operator[](size_t index) {
        return data[index];
    }
    
    // Const version: read-only access
    const int& operator[](size_t index) const {
        return data[index];
    }
};

Fonksiyon Çağırma Operatörü

Çağrılar arasında durum (state) koruyabilen functor'lar oluşturur:

class Multiplier {
    int factor;
    
public:
    Multiplier(int f) : factor(f) {}
    
    int operator()(int value) const {
        return value * factor;
    }
};

Multiplier triple(3);
int result = triple(10);    // Returns 30

Functor'lar, saklanan yapılandırma ile özelleştirilebilir davranışın gerekli olduğu STL algoritmalarında kullanışlıdır.

Kendin dene

#include <iostream>
#include <string>
#include "ScoreTracker.h"

using namespace std;

// TODO: ScoreTracker kurucusunu (constructor) uygula
ScoreTracker::ScoreTracker(size_t size, double multiplier) {
    // TODO: Üyeleri ilklendir ve dinamik diziyi tahsis et
    // Tüm skorları 0 olarak ilklendir
}

// TODO: ScoreTracker yıkıcı metodunu (destructor) uygula
ScoreTracker::~ScoreTracker() {
    // TODO: Dinamik belleği temizle
}

// TODO: Sabit olmayan (non-const) subscript operator uygula

// TODO: Sabit (const) subscript operator uygula

// TODO: Fonksiyon çağırma operatörünü (function call operator) uygula

// TODO: getSize metodunu uygula
size_t ScoreTracker::getSize() const {
    // TODO: Skor sayısını döndür
}

int main() {
    string line;
    
    // Oyuncu sayısını oku
    getline(cin, line);
    size_t numPlayers = stoi(line);
    
    // Bonus çarpanını oku
    getline(cin, line);
    double multiplier = stod(line);
    
    // TODO: numPlayers ve multiplier ile ScoreTracker oluştur
    
    // TODO: Her oyuncu için skorları oku ve subscript operator kullanarak sakla
    
    // TODO: Test skorunu oku
    
    // TODO: Tüm oyuncu skorlarını şu formatta görüntüle: "Player X: <score>"
    
    // TODO: Bonus uygulanmış sonucu şu formatta görüntüle: "Bonus applied to <test_score>: <result>"
    
    return 0;
}