Aritmetik Operatör Aşırı Yükleme

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

+, -, * ve / gibi aritmetik operatörler, özel sınıfların yerleşik sayısal türler gibi davranmasını sağlamak için yaygın olarak aşırı yüklenir. Bu operatörler genellikle işlenenleri değiştirmek yerine yeni bir nesne döndürür.

İşte aritmetik operatörlere sahip bir Fraction sınıfı:

class Fraction {
    int numerator, denominator;
    
public:
    Fraction(int n, int d) : numerator(n), denominator(d) {}
    
    Fraction operator+(const Fraction& other) const {
        return Fraction(
            numerator * other.denominator + other.numerator * denominator,
            denominator * other.denominator
        );
    }
    
    Fraction operator*(const Fraction& other) const {
        return Fraction(numerator * other.numerator, 
                        denominator * other.denominator);
    }
};

Her iki işleneni de değiştirmedikleri için her iki operatörün de const olarak işaretlendiğine dikkat edin. Sonuçla birlikte yeni bir Fraction oluşturur ve döndürürler.

+= gibi bileşik atama operatörleri için kalıp farklıdır. Bunlar sol işleneni değiştirir ve ona bir referans döndürür:

Fraction& operator+=(const Fraction& other) {
    numerator = numerator * other.denominator + other.numerator * denominator;
    denominator = denominator * other.denominator;
    return *this;
}

Yaygın bir uygulama, kod tekrarını azaltmak için temel operatörü bileşik atama cinsinden uygulamaktır:

Fraction operator+(const Fraction& other) const {
    Fraction result = *this;    // Bu nesneyi kopyala
    result += other;            // Bileşik atama kullan
    return result;
}

Bu yaklaşım, her iki operatörün de tutarlı kalmasını sağlar ve bakımı kolaylaştırır.

Görev

Kolay

Aritmetik operatör aşırı yüklemesini (operator overloading) kullanarak para birimi hesaplamalarını yöneten bir Money sınıfı oluşturalım. Para değerleriyle normal sayılarla çalıştığınız kadar doğal bir şekilde çalışmanıza olanak tanıyan birden fazla aritmetik operatör uygulayacaksınız.

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

Money.h: Kayan noktalı sayı hassasiyet sorunlarını önlemek için miktarı sent (bir int olarak) cinsinden saklayan bir Money sınıfı tanımlayın. Sınıfınız şunları desteklemelidir:
- Dolar ve senti ayrı tam sayılar olarak alan bir yapıcı (constructor)
- Dolar kısmını döndüren bir alıcı (getter) getDollars()
- Sent kısmını (0-99) döndüren bir alıcı (getter) getCents()
- Yeni bir Money nesnesi döndüren aşırı yüklenmiş + ve - operatörleri
- Mevcut nesneyi değiştiren ve ona bir referans döndüren aşırı yüklenmiş += ve -= bileşik atama operatörleri
- Parayı $X.YY formatında yazdıran bir display() metodu (sentler için her zaman iki basamak)
Kod tekrarını azaltmak için, derste gösterildiği gibi temel operatörleri (+ ve -) bileşik atama operatörleri cinsinden uygulayın. Tüm aritmetik operatörler uygun yerlerde const olarak işaretlenmelidir.
main.cpp: İki para miktarını temsil eden dört tam sayıyı girdiden okuyun (ayrı satırlarda dollars1, cents1, dollars2, cents2). İki Money nesnesi oluşturun, ardından tüm operatörlerinizi gösterin:
- "Amount 1: " yazdırın ve ardından görüntülenen ilk miktarı yazdırın
- "Amount 2: " yazdırın ve ardından görüntülenen ikinci miktarı yazdırın
- İki miktarı toplayın ve "Sum: " yazdırın, ardından sonucu yazdırın
- İkinciyi birinciden çıkarın ve "Difference: " yazdırın, ardından sonucu yazdırın
- İkinci miktarı birinciye eklemek için += kullanın, ardından "After +=: " yazdırın ve değiştirilmiş ilk miktarı yazdırın

display() metodu için, sentlerin her zaman iki basamak gösterilmesini sağlamak amacıyla <iomanip> kütüphanesinden std::setw(2) ve std::setfill('0') kullanın (örneğin, $5.7 değil $5.07).

Girdi dizelerini std::stoi() kullanarak tam sayılara dönüştürün. Başlık dosyanızda başlık koruyucularını (header guards) unutmayın.

Kopya kağıdı

+, -, * ve / gibi aritmetik operatörler, özel sınıfların yerleşik sayısal türler gibi davranmasını sağlamak için aşırı yüklenebilir. Bu operatörler genellikle işlenenleri değiştirmek yerine yeni bir nesne döndürür.

Temel aritmetik operatörler, her iki işleneni de değiştirmedikleri için const olarak işaretlenmelidir:

Fraction operator+(const Fraction& other) const {
    return Fraction(
        numerator * other.denominator + other.numerator * denominator,
        denominator * other.denominator
    );
}

+= ve -= gibi bileşik atama operatörleri, sol işleneni değiştirir ve ona bir referans döndürür:

Fraction& operator+=(const Fraction& other) {
    numerator = numerator * other.denominator + other.numerator * denominator;
    denominator = denominator * other.denominator;
    return *this;
}

Yaygın bir uygulama, kod tekrarını azaltmak için temel operatörleri bileşik atama operatörleri cinsinden uygulamaktır:

Fraction operator+(const Fraction& other) const {
    Fraction result = *this;    // Bu nesneyi kopyala
    result += other;            // Bileşik atamayı kullan
    return result;
}

Kendin dene

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

using namespace std;

int main() {
    // İki para miktarı için girişi oku
    string line;
    
    getline(cin, line);
    int dollars1 = stoi(line);
    
    getline(cin, line);
    int cents1 = stoi(line);
    
    getline(cin, line);
    int dollars2 = stoi(line);
    
    getline(cin, line);
    int cents2 = stoi(line);
    
    // TODO: Giriş değerleriyle iki Money nesnesi oluştur
    
    // TODO: "Amount 1: " yazdır ve ardından görüntülenen ilk miktarı ekle
    
    // TODO: "Amount 2: " yazdır ve ardından görüntülenen ikinci miktarı ekle
    
    // TODO: İki miktarı topla ve "Sum: " yazdırıp ardından sonucu ekle
    
    // TODO: İkinciyi birinciden çıkar ve "Difference: " yazdırıp ardından sonucu ekle
    
    // TODO: İkinci miktarı birinciye eklemek için += kullan, ardından "After +=: " yazdırıp değiştirilmiş ilk miktarı ekle
    
    return 0;
}