class a
{
public:
void printme() {cout<<"hello"<<endl;}
};
class b : public class a
{
public printme() {cout<<"bye"<<endl;}
}
void main()
{
a* tmp = new b;
tmp->printme();
delete tmp;
}

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

אני זוכר גם שאם לא עושים ירושה פרק וירטואלי בירושה וירטואלית (אפילו אם המפרק ריק!) יש מצב לקריסה.. אני חושב שC++ עלול לנסות למחוק את 2 מופעי הבסיס... ואז אחרי שהוא שיחרר אחד לגשת לאותו מקום בזיכרון ולנסות לשחררו שוב עלול לגרום לקריסה.. למה זה קורה? אני כבר לא זוכר... איפה עידן הוא בטח יודע עם כל הקיראות המרובות שלו בקומפיילרים של C++ ?

מכיוון שכל המתודות הן סטטיות ב-++C, ברגע שאתה רושם delete a; מתבצע הדיסטרקטור לפי הטיפוס הסטטי, כלומר A.
ברגע שאתה מוסיף virtual, בעזרת (תורה יפהפייה בפני עצמה שמאחורי הקלעים) מופעל הדיסטרקטור של הטיפוס הדינמי.

תריץ למשל את קטע הקוד הבא ותראה מה אתה רואה:

#include <iostream>
using namespace std;
class A {
public:
	A() { x = new int; *x = 3; }
	~A() { delete x; }
	int *x;
};
class B : A {
public:
	B() { y = new int; *y = 4; }
	~B() { delete y; }
	int *y;
};
int main() {
	int *ptr;
	B* b = new B();
	ptr = b->y;
	A* a = (A*)b;   // A regular upcasting
	delete a;
	cout << *ptr << endl;
	return 0;
}

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

// Right Overloading
class A
{
public:
	A();
	A(int num) : x(num),y(num) {}
protected:
	int x,y;
	
	friend A operator+(const A& first,const A& second);
};
A operator+(const A& first,const A& second)
{
	A result;
	result.x = first.x + second.x;
	result.y = first.y + second.y;
	return result;
}
// Wrong Overloading
class B
{
public:
	B();
	B(int num) : x(num),y(num) {}
	B operator+(const B& other)
	{
		B result;
		result.x = x+other.x;
		result.y = y+other.y;
		return result;
	}
protected:
	int x,y;		
};
int main()
{
	A a = 3;
	B b = 5;
	A result = a +9;
	result = 9 + a;
	B result2 = b + 9;
	result2 = 9 +b; // error : lvalue expects an object 
	return 0;
}

class A;
class B : virtual A;
class C : virtual A;
class D : B, C (אפשר גם וירטואלית)

אז זו ירושת יהלום.
וב-VS הבעיה כל-כך קשה, מסתבר, שזה מתקמפל ועובד

במקום ירושה שתראה ככה:

אז היא נראת ככה (בצורת יהלום):
http://www.programmerinterview.com/images/Diamond_inheritance.png
הוירטואליות גורמת להצבעה לאובייקט משותף במקום ל-2 אינסטנסים נפרדים...

הסברתי בדוגמא למה עדיף להשתמש בפונקציה גלובלית על פני פונקציה במחלקה.

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

העמסת אופרטורים טובה מאוד כאשר עובדים במקביל עם טיפוסים פרמטיביים,
למרות שתמיד אפשר לבצע inboxing ב-Java (קצת יותר בעייתי ב-#C) ולהעזר במתודות בעלות שם משותף.

ב-C# הגיעו למסקנה שפויינטרים לפעמים זה כן דבר נחוץ.

בסה"כ, הכל עניין של perfomance מול קלות תכנות.
ו-C לא הייתה השפה מס' 1 בשוק כיום אם הפרפומנס לא היה חשוב כמו שהוא חשוב.