Operatör Aşırı Yükleme

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

Operatör aşırı yüklemesi, +, - veya == gibi operatörlerin özel sınıflarınızla nasıl davranacağını tanımlamanıza olanak tanır. point1.Add(point2) gibi metotları çağırmak yerine, daha doğal olan point1 + point2 ifadesini yazabilirsiniz.

Bir operatörü aşırı yüklemek için, operator anahtar kelimesini kullanarak özel bir statik metot oluşturursunuz:

public class Vector
{
    public int X { get; }
    public int Y { get; }
    
    public Vector(int x, int y)
    {
        X = x;
        Y = y;
    }
    
    public static Vector operator +(Vector a, Vector b)
    {
        return new Vector(a.X + b.X, a.Y + b.Y);
    }
}

Artık vektörleri doğal bir şekilde toplayabilirsiniz:

Vector v1 = new Vector(3, 4);
Vector v2 = new Vector(1, 2);
Vector v3 = v1 + v2;  // X = 4, Y = 6

Metot public static olmalıdır ve en az bir parametre kapsayan tür olmalıdır. Aritmetik operatörleri (+, -, *, /), karşılaştırma operatörlerini (==, !=, <, >) ve tekli operatörleri (-, !, ++) aşırı yükleyebilirsiniz.

Karşılaştırma operatörlerinin çiftler halinde aşırı yüklenmesi gerektiğini unutmayın - eğer == tanımlarsanız, != operatörünü de tanımlamanız gerekir.

Operatör aşırı yüklemesini, özellikle vektörler, karmaşık sayılar veya para gibi matematiksel türler için kodunuzu daha sezgisel hale getirdiğinde kullanın. İşlemin anlamı hemen belli olmadığında bundan kaçının.

Görev

Kolay

Operatör aşırı yüklemesi (operator overloading) yoluyla kesirlerle çalışmayı doğal hale getiren bir Fraction sınıfı oluşturalım. fraction1.Add(fraction2) gibi metotları çağırmak yerine, sezgisel olan fraction1 + fraction2 yazabileceksiniz.

Kodunuzu iki dosya halinde düzenleyeceksiniz:

Fraction.cs: Math ad alanı (namespace) içinde, bir pay ve paydayı temsil eden bir Fraction sınıfı oluşturun. Kesir sınıfınız şunlara sahip olmalıdır:
- İki adet salt okunur (read-only) tam sayı özelliği: Numerator ve Denominator
- Pay ve paydayı (bu sırayla) kabul eden bir yapıcı metot (constructor)
- Şu formülü kullanarak iki kesri toplayan aşırı yüklenmiş bir + operatörü: (a/b) + (c/d) = (a*d + c*b) / (b*d)
- İki kesri çarpan aşırı yüklenmiş bir * operatörü: (a/b) * (c/d) = (a*c) / (b*d)
- İki kesrin eşit olup olmadığını döndüren aşırı yüklenmiş bir == operatörü (karşılaştırmak için çapraz çarpım yapın: a*d == c*b)
- == operatörünü aşırı yüklediğinizde gerekli olan ve == operatörünün zıttını döndüren aşırı yüklenmiş bir != operatörü
- Kesri "{Numerator}/{Denominator}" formatında bir dize (string) olarak döndüren bir GetDisplay() metodu
Program.cs: Ana dosyanızda, girdi değerlerini kullanarak iki kesir oluşturun. Bunları toplayarak, çarparak ve eşit olup olmadıklarını kontrol ederek aşırı yüklenmiş operatörleri gösterin. Operatörlerinizin doğal bir şekilde çalıştığını göstermek için sonuçları yazdırın.

Dört adet girdi alacaksınız:

Birinci kesrin payı (tam sayı)
Birinci kesrin paydası (tam sayı)
İkinci kesrin payı (tam sayı)
İkinci kesrin paydası (tam sayı)

Çıktıyı şu formatta yazdırın:

Fraction 1: {GetDisplay()}
Fraction 2: {GetDisplay()}
Sum: {GetDisplay()}
Product: {GetDisplay()}
Are equal: {True/False}

Örneğin, girdiler 1, 2, 2 ve 4 ise çıktı şöyle olmalıdır:

Fraction 1: 1/2
Fraction 2: 2/4
Sum: 8/8
Product: 2/8
Are equal: True

1/2 ve 2/4'ün 1*4 == 2*2 olduğu için nasıl eşit olarak tanındığına dikkat edin. Toplam ve çarpım sadeleştirme yapılmadan hesaplanır - bu meydan okuma için bu durum sorun teşkil etmez. İşin güzelliği, artık tanıdık operatörleri kullanarak kesirlerle ne kadar doğal bir şekilde çalışabildiğinizdedir!

Kopya kağıdı

Operatör aşırı yükleme (operator overloading), sınıflarınızla +, -, *, == gibi operatörler için özel davranışlar tanımlamanıza olanak tanır.

Bir operatörü aşırı yüklemek için, operator anahtar kelimesini kullanarak public static bir metot oluşturun. Parametrelerden en az biri kapsayan tür olmalıdır:

public class Vector
{
    public int X { get; }
    public int Y { get; }
    
    public Vector(int x, int y)
    {
        X = x;
        Y = y;
    }
    
    public static Vector operator +(Vector a, Vector b)
    {
        return new Vector(a.X + b.X, a.Y + b.Y);
    }
}

Kullanım:

Vector v1 = new Vector(3, 4);
Vector v2 = new Vector(1, 2);
Vector v3 = v1 + v2;  // X = 4, Y = 6

Şunları aşırı yükleyebilirsiniz:

Aritmetik operatörler: +, -, *, /
Karşılaştırma operatörleri: ==, !=, <code><, (çiftler halinde aşırı yüklenmelidir)
Tekli (unary) operatörler: -, !, ++

== operatörünü aşırı yüklerken, != operatörünü de aşırı yüklemelisiniz:

public static bool operator ==(Vector a, Vector b)
{
    return a.X == b.X && a.Y == b.Y;
}

public static bool operator !=(Vector a, Vector b)
{
    return !(a == b);
}

Kendin dene

using System;
using Math;

class Program
{
    public static void Main(string[] args)
    {
        // İlk kesir için girişi oku
        int num1 = Convert.ToInt32(Console.ReadLine());
        int den1 = Convert.ToInt32(Console.ReadLine());
        
        // İkinci kesir için girişi oku
        int num2 = Convert.ToInt32(Console.ReadLine());
        int den2 = Convert.ToInt32(Console.ReadLine());
        
        // TODO: Giriş değerlerini kullanarak iki Fraction nesnesi oluşturun
        
        // TODO: Kesirleri toplamak için aşırı yüklenmiş + operatörünü kullanın
        
        // TODO: Kesirleri çarpmak için aşırı yüklenmiş * operatörünü kullanın
        
        // TODO: Eşitliği kontrol etmek için aşırı yüklenmiş == operatörünü kullanın
        
        // TODO: Çıktıyı istenen formatta yazdırın:
        // Fraction 1: {GetDisplay()}
        // Fraction 2: {GetDisplay()}
        // Sum: {GetDisplay()}
        // Product: {GetDisplay()}
        // Are equal: {True/False}
    }
}