ראינו קודם כי יכולים להיות כמה מימושים שונים לאותו ה-$ADT$.
בנוסף, מדי פעם נרצה להגדיר שני דברים שונים כתת דברים של יצור אחר.
הקונספט של $OOP$ הוא של טיפוסים ותתי טיפוסים ובזה אנו עומדים להתמקד עכשיו.

נניח ויש לנו יישום HR ויש לנו שני סוגים של עובדים: מהנדסים ואנשי מכירות.
נניח והיינו מתארים את שניהם במחלקה אחת, היינו מגיעים לבעיה, למהנדס יש תארים ולאיש המכירות אין בעוד שלאיש המכירות יש $commision$ ולמהנס אין.
אם נכתוב מחלקה אחת, נגיע לבלבול:

class Employee
{
public:
	// ...
	string getName() const;
	void giveRaise(int amout);
	enum Type { ENGINEER, SALESPERSON };

private:
	string name;
	Date birth;
	int salary;
	Type type;
	Set<string> degrees; // for an engineer
	double comissionRate; // for a sales person
};

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

הפתרון הנאיבי הוא לצור מחלקה בשם $Employee$ ולשים שדה שלה במחלקות $SalesPerson$ ו-$Engineer$ ואז נשתמש בשיטות שלנו במחלקות החיצוניות יותר בשיטות של $Employee$. (נניח $getName()$ של $Engineer$ פשוט יקרא ל-$getName()$ של $Employee$) זה גם לא טוב במיוחד.

ירושה

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

class Employee
{
public:
	// ...
	string getName() const;
	void giveRaise(int amount);

private:
	string name;
	Date birth;
	int salary;
};

class Engineer : public Employee
{
public:
	// engineer-only functions ...

private:
	Set<string> degrees;
};

void f(Engineer& engineer)
{
	engineer.addDegree("B.Sc. Computer Science");
	engineer.giveRaise(10);
}

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

ב-$UML$ אנו נסמן ירושה עם ראש חץ ריק.

שליטה בגישה

במחלקת הבן, אנו לא יכולים לגשת לשדות והשיטות הפרטיות של מחלקת האב.
אך מה אם אנו רוצים לאפשר גישה לחלק מהשדות והשיטות אך ורק מהמחלקות שיורשות אך לא משאר העולם? נוכל לבצע את זה באמצעות סוג המידע $protected$ וזה נראה כך:

class Employee
{
public:
	string getName() const;
	void giveRaise(int amount);
private:
	string name;
	Date birth;
protected:
	int salary;
};

class Engineer : public Employee
{
public:
	void addReview(string text, int score);
private:
	Set<string> reviews;
};

void Engineer::addReview(string text, int score)
{
	reviews.add(text);
	if (score == 5)
		salary += 1000;
}

void f(Engineer& engineer)
{
	engineer.salary = 1000; // ERROR!!!!!
}

ב-$C++$ בירושה אנו נדרשים להשתמש במצביעים ורפרנסים.
בכך, אם $B$ יורשת מ-$A$ אזי, ניתן להשתמש ב-$B^*$ כ-$A^*$ וניתן להשתמש ב-$B\&$ כ-$A\&$. אך לא הפוך

Engineer engineer("Jane Doe");
SalesPerson salesPerson("John Doe");
Employee employee("John Smith");

Employee& ref = engineer; // ok
Employee* ptr = &salesPerson; // ok

Engineer* ptr2 = &employee; // ERROR!

Employee = copy = engineer; // compiles, but probebly a bug

Employee* array[] = {
	&engineer, &salesPerson, &employee
};

בנאים במחלקות יורשות

בנאים לא עוברים בירושה ובנוסף הבנאי של הבן חייב לקרוא לבנאי של האב.
הסיבה לחלק הראשון היא שהבנאי היא אינה שיטה אלא יצור אחר, היא בעצם שיטה של המחלקה ולא של האובייקט. (קיימות שפות שבהן יש ירושה של הבנאים - $C++$ היא לא אחת מהן)

Employee::Empyloyee(string name)
	: name(name), salary(STARTING_SALARY)
{}

Engineer::Engineer(string name)
	: Employee(name), degrees()
{}

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

הורסים במחלקות יורשות

גם הורס ברירת מחדל נוצר אוטומטית במחלקות יורשות, רק שפה, קודם כל נקרא הקוד בהורס של המחלקה היורשת, אז נקראים ההורסים של שדות המחלקה היורשת ואז נקרא ההורס של המחלקה של האב(ואז נהרסים השדות של מחלקת האב)

ההבדל פה מבנאים, הוא שלא צריך לקרוא ידנית להורס של האב.

Engineer::~Engineer()
{
	// ...
	// no need to call ~Employee()
}

class Engine
{
public:
	Engine() { cout << "Engine ctor" << endl; }
	~Engine() { cout << "Engine dtor" << endl; }
};

class Battery
{
public:
	Battery() { cout << "Battery ctor" << endl; }
	~Battery() { cout << "Battery dtor" << endl; }
};

class Car
{
	Engine engine;
public:
	Car() { cout << "Car ctor" << endl; }
	~Car() { cout << "Car dtor" << endl; }
};

class ElectricCar : public Car
{
	Battery battery;
public:
	ElectricCar() { cout << "ElectricCar ctor" << endl; }
	~ElectricCar() { cout << "ElectricCar dtor" << endl; }
};

// MAIN
int main()
{
	ElectricCar car;
	cout << "========" << endl;
	return 0;
}

Engine ctor
Car ctor
Battery ctor
ElectricCar ctor
========
ElectricCar dtor
Battary dtor
Car dtor
Engine dtor

דריסה של שיטות

מה אם אנו רוצים דרך שונה לחשב את ההעלה של כל סוג של עובד?
נוכל לדרוס את השיטה במחלקות הבנים ובכך להשיג את ההתנהגות שאנו רוצים.

void Employee::giveRaise(int amount)
{
	salary += amount;
}

class SalesPerson : public Employee
{
public:
	// ...
	void giveRaise(int amount);
};

void SalesPerson::giveRaise(int amount)
{
	Employee::giveRaise(amount + comissionRate * sales);
}

אך מה קורה אם יש לנו מערך למצביעים של $Employee$, ואנו קוראים על אחד האיברים, איזו שיטה צריכה להיקרא? הזאת של $Employee$ או הזאת של המחלקה היורשת המתאימה?

פתרון ראשון

הפתרון הראשון די מגעיל והוא דורש השמה בתצורה כזו:

Employee* employees[] = { ... };

for (int i = 0; i < n; ++i)
{
	Employee *e = employees[i];
	((SalesPerson*)e)->giveRaise(100);
}

זה מגעיל ויכול ליצור מלאאא בגים! אנו לא רוצים את הפתרון הראשון.

דרך לפתור את הבעיות עם המצביעים היא להשתמש ב-$static\_cast$ שהוא החלפה טובה יותר של השמה של $C$ ביצור חדיש יותר של $C++$. בתצורה זו, השמה בין שני דברים לא קשורים לא תתקמפל.

Employee* employees[] = { ... };

for (int i = 0; i < n; ++i)
{
	if (employees[i]->getType() == "manager")
		static_cast<SalesPerson*>(cmployees[i])->giveRaise(100);
}

זה יותר טוב, אך אנו עדיין לא אוהבים את זה כל כך.

הפתרון הנכון: שיטות וירטואליות

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

class Employee
{
public:
	// ...
	virtual void giveRaise(int amount);
};

class SalesPerson : public Employee
{
public:
	// ...
	void giveRaise(int amount);
};

int func()
{
	SalsesPerson salesPerson("John Doe");
	Employee* emp = &salesPerson;
	
	emp->giveRaise(1000);
	
	return 0;
}

המילה השמורה $override$

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

class Employee
{
public:
	virtual void giveRaise(int amount);
};

class QASpecialist : public Employee
{
public:
	// ...
	void giveRaise(int amount) override;
};

מחלקה אבסטרקטית

בהרבה מקרים מחלקת האב מייצגת קונספט אבסטרקטי שאין לו מימוש בפני עצמו.
במקרים כאלו אנו יכולים להגדיר פונקציה וירטואלית לגמרי($pure\;virtual\;function$) אשר אין לה מימוש במחלקת האב.

class Employee
{
public:
	// ...
	virtual void giveRaise(int amount) = 0;
};

class SalesPerson : public Employee
{
public:
	// ...
	void giveRaise(int amount) override;
};

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

class Employee
{
	// ...
public:
	virtual ~Employee() {}
	// ...
};

מחלקת ממשק - $Interface$

ממשק מתאר את ההתנהגות הבסיסית של מחלקה מבלי לתאר איזשהו מימוש מדוייק.

class Shape
{
public:
	virtual ~Shape() {}
	virtual void rotate(double angle) = 0;
	virtual void draw() const = 0;
	virtaul double area() const = 0;
};

$Polymorphism$

אנו דיברנו כבר על $Polymorphism$ שכן דיברנו כבר על תכנות גנרי ואמרנו שזה $Parametric\;Polymorphism$.
בקורס הזה אנו קוראים ל-$Subtyping\;Polymorphism$ פשוט $Polymorphism$.
הרעיון של פולימורפיזם הוא פשוט שכאשר אנו יוצרים מחלקה יורשת חדשה, שום חלק במחלקת האב לא צריך להשתנות.

כל קוד שקשור לתת קטגוריה ספציפית נמצא אך ורק במחלקה של התת קטגוריה.

פולימורפיזם ובנאי העתקה

נזכר כי אם יש לנו מחלקת אב $Employee$ ומחלקת בן $Engineer$ ואנו כותבים את הקוד הבא:

Engineer eng("Bjarne Stroustrup");
Employee emp = eng;

הבנאי שנקרא בשורה השנייה הוא בנאי ההעתקה של $Employee$ ולכן, כל הדברים שקשורים ספציפית ל-$Engineer$ נעלמים כאילו לא היו. גם השיטות שיקראו הן המימושים של $Employee$ ולא של $Engineer$.

בפוינטרים אין את הבעיה הזו, אך איך אנו יכולים לבצע העתקה של אובייקט ללא קריאה לבנאי ההעתקה?
(אנו לא רוצים לקרוא לבנאי ההעתקה כי אנו לא בטוחים בדיוק מאיזה סוג האובייקט, שכן זוהי כל הפואנטה של $OOP$)

כדי לפתור בעיה זאת אנו ניצור שיטה וירטואלית לגמרי בשם $clone$ אשר תחזיר פוינטר לאובייקט.
היא תראה משהו כזה:

class Shape
{
	// ...
public:
	virtual Shape* clone() const = 0;
	// ...
};

class Circle : public Shape
{
	// ...
public:
	Circle(double radius);
	Shape* clone() const override;
	// ...
};

Shape* Circle::clone() const
{
	return new Circle(*this);
}

int main()
{
	Shape* ptr = new Circle(0,0,3);
	Shape* copy = ptr->clone();
}

כשצריך סוג ספציפי של יצור

לפעמים אנו רוצים לדעת באיזה סוג מחלקה אנחנו, נניח אם יש לנו פעולה שמתעסקת עם שדות מסויימים של תת מחלקה מסויימת (נניח אם יש לנו מחלקת אב של יחס ומחלקת בן של פונקציה ואנו רוצים לעשות משהו רק עבור פונקציות)

נשים לב כי אם יש לנו מצביע של $Employee$ אנו לא נוכל לקרוא לשיטה שמוגדרת רק ב-$Engineer$ שכן אנו לא ידועים אם זה באמת מהנדס או לא.
משהו נוסף שלא נעשה הוא להוסיף שיטה $type$ אשר בעזרתה נבדוק איזה סוג זה כי זה מגעיל.

הפתרון לבעיה המוצעת פה היא שימוש בסוגים דינאמים וב-$dynamic\_cast$.
ה-$dynamic\_cast$ משים אובייקט מסוג של מחלקת אב לאובייקט מסוג טיפוס של הבן והיא תחזיר $nullptr$ אם זה לא הגיוני

void printDegrees(const Employee* employees[], int n)
{
	for (int i = 0; i < n; ++i)
	{
		const Engineer* eng = dynamic_cast<const Engineer*>(employees[i]);
		if (eng != nullptr)
		{
			eng->printDegrees();
		}
	}
}

סיכום השמות($casting$)

ראינו כי לבצע השמות כמו שעשינו ב-$C$ זה לא טוב כלל וכלל!!!!

const double height = 175.3;
int* height_ptr = (int*) &height; //NOOOOOOOOO

יש לנו ב-$C++$ שני סוגים של השמות:

1. $static\_cast$ מאפשר לנו להמיר בין שני סוגים שידועים בזמן ההמרה, כלומר, לא מחלקות עם ירושה.
   כדאי להשתמש באלו רק עבור טיפוסים פרימיטביים.
2. $dynamic\_cast$ מאפשר לנו להמיר בין שני מצביעים או רפרנסים שיש להם איזשהו קשר ירושתי שכזה.
   האחד הזה נבדק במהלך זמן הריצה.

ירושה ושגיאות

ראינו שגיאות באחד מהפרקים הקודמים וכעת נוכל לשפר את יכולת ההתמודדות שלנו עם שגיאות.
בבלוק $catch$ התפיסה של סוג מתחשב גם בכל הבנים שלו, נניח אם אנחנו תופסים $Employee$ זה יתפוס גם $Engineer$ ו-$SalesPerson$ וכו'.

class GradesException
{
public:
	virtual ~GradesException() {}
};

class NotEnrolled : public GradesException {};
class NoSuchStudent : public GradesException {};

void GradesSystem::printGrade(string student, int course)
{
	try
	{
		cout << "grade is: " getGrade(student, course);
	}
	catch (const NotEnrolled&)
	{
		cerr << studentName << " is not registered";
	}
	catch (const GradesException&)
	{
		cerr << "Data not avilable";
	}
}

בספריה הסטנדרטית מוגדרות לנו שגיאות טיפוסיות וכדאי לבצע מהן ירושה עבור השגיאות שלנו.

class exception
{
public:
	exception();
	exception(const exception&);
	exception& operator=(const exception&);
	virtual ~exception();
	virtual const char* what() const noexcept; // noexcpet says there wont be an exception comming from this function
};

יש לנו שני סוגים בסיסיים של שגיאות:

1. $logic\_error$ - מייצג את השגיאות שהקורא לפונקציה יכול היה לגלות עליהן, לדוגמה: $index\;out\;of\;bounds$.
2. $runtime\_error$ - מייצג את השגיאות שקורות כאשר הפונקציות רצות ולא היה ניתן לדעת עליהן בהקדם(שגיאות משתמש נניח)