העמסת אופרטורים

חלק מהיחידה תכנות מונחה עצמים במסלול ה-C# של Coddy. שיעור 36 מתוך 70.

העמסת אופרטורים מאפשרת לך להגדיר כיצד אופרטורים כמו +, - או == פועלים עם מחלקות מותאמות אישית שלך. במקום לקרוא למתודות כמו point1.Add(point2), אפשר לכתוב בצורה טבעית יותר point1 + point2.

כדי להעמיס אופרטור, יוצרים מתודה סטטית מיוחדת באמצעות מילת המפתח operator:

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);
    }
}

עכשיו אפשר להוסיף וקטורים באופן טבעי:

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

המתודה חייבת להיות public static, ולפחות אחד הפרמטרים חייב להיות מהטיפוס המכיל. אפשר להעמיס אופרטורים אריתמטיים (+, -, *, /), אופרטורי השוואה (==, !=, <, >) ואופרטורים אונריים (-, !, ++).

שים לב שיש להעמיס אופרטורי השוואה בזוגות — אם תגדיר את ==, עליך להגדיר גם את !=.

השתמשו בהעמסת אופרטורים כשהיא הופכת את הקוד שלכם לאינטואיטיבי יותר, במיוחד עבור טיפוסים מתמטיים כמו וקטורים, מספרים מרוכבים או כסף. הימנעו ממנה כשהמשמעות של הפעולה אינה ברורה מיד.

אתגר

קל

בואו נבנה מחלקה Fraction שתאפשר לעבוד עם שברים באופן טבעי באמצעות העמסת אופרטורים. במקום לקרוא למתודות כמו fraction1.Add(fraction2), תוכלו לכתוב את הביטוי האינטואיטיבי fraction1 + fraction2.

תארגנו את הקוד בשני קבצים:

Fraction.cs: צרו מחלקה Fraction במרחב השמות Math, שמייצגת שבר עם מונה ומכנה. לשבר שלכם צריכים להיות:
- שתי תכונות של מספרים שלמים לקריאה בלבד: Numerator ו-Denominator
- בנאי שמקבל את המונה ואת המכנה (בסדר הזה)
- אופרטור + מועמס שמחבר שני שברים באמצעות הנוסחה: (a/b) + (c/d) = (a*d + c*b) / (b*d)
- אופרטור * מועמס שמכפיל שני שברים: (a/b) * (c/d) = (a*c) / (b*d)
- אופרטור == מועמס שמחזיר true אם שני שברים שווים (השוו באמצעות כפל בהצלבה: a*d == c*b)
- אופרטור != מועמס (נדרש כשמעמיסים את ==) שמחזיר את ההפך מ-==
- מתודה GetDisplay() שמחזירה את השבר כמחרוזת בפורמט "{Numerator}/{Denominator}"
Program.cs: בקובץ הראשי שלכם, צרו שני שברים באמצעות ערכי הקלט. הדגימו את האופרטורים המועמסים על ידי חיבור השברים, הכפלתם ובדיקה אם הם שווים. הדפיסו את התוצאות כדי להראות שהאופרטורים פועלים באופן טבעי.

תקבלו ארבעה ערכי קלט:

המונה של השבר הראשון (מספר שלם)
המכנה של השבר הראשון (מספר שלם)
המונה של השבר השני (מספר שלם)
המכנה של השבר השני (מספר שלם)

הדפיסו את הפלט בפורמט הזה:

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

לדוגמה, אם ערכי הקלט הם 1, 2, 2 ו-4, הפלט צריך להיות:

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

שימו לב ש-1/2 ו-2/4 מזוהים כשווים, כי 1*4 == 2*2. הסכום והמכפלה מחושבים ללא צמצום — זה בסדר גמור באתגר הזה. היופי הוא שכעת אפשר לעבוד עם שברים באופן טבעי כל כך, באמצעות אופרטורים מוכרים!

נסו בעצמכם

using System;
using Math;

class Program
{
    public static void Main(string[] args)
    {
        // קראו קלט עבור השבר הראשון
        int num1 = Convert.ToInt32(Console.ReadLine());
        int den1 = Convert.ToInt32(Console.ReadLine());
        
        // קראו קלט עבור השבר השני
        int num2 = Convert.ToInt32(Console.ReadLine());
        int den2 = Convert.ToInt32(Console.ReadLine());
        
        // TODO: צרו שני אובייקטים מסוג Fraction באמצעות ערכי הקלט
        
        // TODO: השתמשו באופרטור + המועמס כדי לחבר את השברים
        
        // TODO: השתמשו באופרטור * המועמס כדי להכפיל את השברים
        
        // TODO: השתמשו באופרטור == המועמס כדי לבדוק שוויון
        
        // TODO: הדפיסו את הפלט בפורמט הנדרש:
        // שבר 1: {GetDisplay()}
        // שבר 2: {GetDisplay()}
        // סכום: {GetDisplay()}
        // מכפלה: {GetDisplay()}
        // האם שווים: {True/False}
    }
}