סיכום – מחלקת Matrix

חלק מהיחידה תכנות מונחה עצמים במסלול ה-C++ של Coddy. שיעור 47 מתוך 104.

אתגר

קל

בואו נבנה מחלקה Matrix שמאגדת את כל טכניקות העמסת האופרטורים שלמדת בפרק הזה. תיצור מטריצה מלאה שתומכת בפעולות חשבון, השוואות, גישה לאיברים ופלט לזרם — והכול באמצעות תחביר אינטואיטיבי של אופרטורים.

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

Matrix.h: הגדר מחלקה Matrix שמנהלת מערך דו־ממדי של מספרים שלמים באמצעות זיכרון דינמי. המטריצה שלך צריכה לתמוך ב:
- חברים פרטיים: מצביע int** לנתונים הדו־ממדיים, וחברי size_t עבור שורות ועמודות
- בנאי שמקבל מספר שורות ועמודות ומאתחל את כל האיברים ל־0
- הורס שמשחרר כראוי את כל הזיכרון שהוקצה
- בנאי העתקה ואופרטור השמת העתקה (העתקה עמוקה עם בדיקת השמה עצמית)
- פונקציות הגישה getRows() ו־getCols() (שתיהן const)
- מתודת set(row, col, value) להגדרת איברים בודדים
- מתודת get(row, col) מסוג const לשליפת איברים
ממש את האופרטורים הבאים:
- חשבון: + ו־- לחיבור וחיסור מטריצות (החזר Matrix חדש לפי ערך)
- השוואה: == ו־!= לבדיקה אם לשתי מטריצות יש את אותם ממדים ואיברים זהים
- זרם: << כפונקציית friend שמוציאה את המטריצה שורה אחר שורה, עם רווחים בין האיברים ושורה חדשה אחרי כל שורה
- אינדקס: [] שמחזיר מצביע לשורה, ומאפשר תחביר matrix[row][col] (ספק גם גרסה const וגם גרסה שאינה const)
באופרטורים החשבוניים, הנח שלשתי המטריצות יש אותם ממדים. אופרטורי ההשוואה צריכים להחזיר false אם הממדים שונים.
main.cpp: קרא קלט כדי ליצור ולתפעל שתי מטריצות 2x2. פורמט הקלט הוא:
1. ארבעה מספרים שלמים עבור המטריצה הראשונה (שורה אחר שורה): a00, a01, a10, a11
2. ארבעה מספרים שלמים עבור המטריצה השנייה (שורה אחר שורה): b00, b01, b10, b11
צור שני אובייקטים מסוג Matrix (2 שורות ו־2 עמודות בכל אחד), מלא אותם באמצעות המתודה set(), ואז הדגם את האופרטורים שלך:

פורמט הפלט:
```
Matrix A:
<row0>
<row1>
Matrix B:
<row0>
<row1>
A + B:
<row0>
<row1>
A - B:
<row0>
<row1>
A == B: <true/false>
A != B: <true/false>
A[0][0]: <value>
A[1][1]: <value>
```
בכל שורה יש להציג את האיברים כשהם מופרדים ברווח יחיד. הדפס true או false (באותיות קטנות) עבור תוצאות ההשוואה.

לדוגמה, עבור הקלט 1 2 3 4 למטריצה A ו־5 6 7 8 עבור Matrix B:

Matrix A:
1 2
3 4
Matrix B:
5 6
7 8
A + B:
6 8
10 12
A - B:
-4 -4
-4 -4
A == B: false
A != B: true
A[0][0]: 1
A[1][1]: 4

השתמש ב־std::stoi() להמרת הקלט. זכור לממש את != באמצעות == כדי לשמור על עקביות בין האופרטורים. אל תשכח להוסיף הגנות הכללה לקובץ הכותרת שלך.

נסו בעצמכם

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

using namespace std;

int main() {
    // קראו קלט עבור המטריצה הראשונה (2x2): a00, a01, a10, a11
    int a00, a01, a10, a11;
    cin >> a00 >> a01 >> a10 >> a11;
    
    // קראו קלט עבור המטריצה השנייה (2x2): b00, b01, b10, b11
    int b00, b01, b10, b11;
    cin >> b00 >> b01 >> b10 >> b11;
    
    // TODO: צרו שני אובייקטים מסוג Matrix (2 שורות ו-2 עמודות בכל אחד)
    
    // TODO: מלאו את המטריצות באמצעות המתודה set()
    
    // TODO: הציגו את Matrix A
    // cout << "Matrix A:" << endl;
    // השתמשו באופרטור << כדי להדפיס את המטריצה
    
    // TODO: הציגו את Matrix B
    // cout << "Matrix B:" << endl;
    // השתמשו באופרטור << כדי להדפיס את המטריצה
    
    // TODO: הציגו את A + B
    // cout << "A + B:" << endl;
    
    // TODO: הציגו את A - B
    // cout << "A - B:" << endl;
    
    // TODO: הצג את תוצאות ההשוואה
    // cout << "A == B: " << (השתמש באופרטור תנאי עבור true/false) << endl;
    // cout << "A != B: " << (השתמש באופרטור תנאי עבור true/false) << endl;
    
    // TODO: הצג את תוצאות הגישה באמצעות אינדקסים
    // cout << "A[0][0]: " << ... << endl;
    // cout << "A[1][1]: " << ... << endl;
    
    return 0;
}