 C++ heeft een inheritance mechanisme  Manier om functionaliteit te ‘erfen’ van een parrent class ◦ Polymorphisme ◦ Zoals we het ook in C# kennen.

Presentatie over: " C++ heeft een inheritance mechanisme  Manier om functionaliteit te ‘erfen’ van een parrent class ◦ Polymorphisme ◦ Zoals we het ook in C# kennen."— Transcript van de presentatie:

1

2  C++ heeft een inheritance mechanisme  Manier om functionaliteit te ‘erfen’ van een parrent class ◦ Polymorphisme ◦ Zoals we het ook in C# kennen

3 class A { public: void doeDing() { cout<<"Ding!"<<endl; } }; class B : public A { };

4 int main() { A a; B b; a.doeDing(); b.doeDing(); return 0; } Output: Ding!

5  Net als in C# kunnen we functies uit de base class overriden  Hiervoor moet een function in de base class met virtual aangeduid worden

6 class A { public: virtual void doeDing() { cout<<"Ding!"<<endl; } }; class B : public A { public: void doeDing() { cout<<“Nog Een Ding!"<<endl; } };

7 int main() { A a; B b; a.doeDing(); b.doeDing(); return 0; } Output: Ding! Nog Een Ding!

8  Let op bij overloading!  Stel we overriden maar 1 variant van een virtual overloaded function: class A { public: virtual void doeDing() { cout<<"Ding!"<<endl;} virtual void doeDing(char* a) { cout<<a<<endl;} }; class B : public A { public: void doeDing() {cout<<"Dang!"<<endl;} };

9  En nu proberen we een string argument mee te geven bij een B object B b; b.doeDing("Bam!"); error C2660: 'B::doeDing' : function does not take 1 arguments

10  Voeg daarom expliciet de overloads toe aan je nieuwe class! class A { public: virtual void doeDing() { cout<<"Ding!"<<endl;} virtual void doeDing(char* a) { cout<<a<<endl;} }; class B : public A { public: void doeDing() {cout<<"Dang!"<<endl;} using A::doeDing; };

11  In C# kunnen zouden we een B object ook kunnen zien als een object met type A, maar... int main() { A a = B(); a.doeDing(); return 0; } Output: Ding!

12  Waarom krijgen we nu als output “Ding!” en niet “Nog Een Ding!” ?  Alles in de variable ‘a’ wordt geinterpreteerd als een object van type ‘A’ ◦ Dit betekend dus ook dat we alle functies van A krijgen!  Hoe lossen we dit op?

13  Bij polymorpishe objecten moeten we ‘indirect’ onze objecten benaderen om het gewenste gedrag te krijgen  Dit lossen we op met pointers! ◦ Bij het dereferencen van de pointer wordt de juiste function pointer opgezocht

14 Output: Nog Een Ding! int main() { A *a = &B(); a->doeDing(); return 0; }

15  Stel we willen functies van de parent class ◦ Scope operator! class A { public: virtual void doeDing() { cout<<"Ding!"<<endl; } }; class B : public A { public: void doeDing() { A::doeDing(); } };

16  De constructor van de parent wordt automatisch aangeroepen ◦ (Voor de constructor van de Child) class A { public: A() { cout<<"ctor A"<<endl; } }; class B : public A { public: B() { cout<<"ctor B"<<endl; } }; B b; Output: ctor A ctor B

17  Als er geen default constructor is, hoe komen we dan aan de argumenten? ◦ Child constructor moet parent constructor aanroepen met correcte argumenten! class A { public: A(char *a) { cout<<a<<endl; } }; class B : public A { public: B() : A("bam!") { } }; B b; Output: bam!

18  Als we een B aanmaken, wordt ook het A deel aangemaakt: dit deel moet ook weer verwijderd worden! ◦ Automagisch.. class A { public: ~A() { cout<<"dtor A"<<endl; } }; class B : public A { public: ~B() { cout<<"dtor B"<<endl; } }; { B b; } Output: dtor B dtor A

19  Maar als we B als een A zien, gaat dat niet zo automagisch! Output: dtor A int main() { A *a = new B(); delete a; return 0; }

20  Heel belangrijk: Maak ook je destructor virtual! class A { public: virtual ~A() { cout<<"dtor A"<<endl; }}; class B : public A { public: ~B() { cout<<"dtor B"<<endl; } }; A *a = new B(); delete a; Output: dtor B dtor A

21  Ook in C++ hebben we abstract classes  Een class is abstract als tenminste één methode een pure virtual fuction is ◦ Virtual met een twist!  Net als in C# kunnen we abstracte classes niet instancieren

22  Een virtual function zonder implementatie (expliciet!) ◦ Een child class moet de virtual function implementeren, anders is ook de child abstract class A { public: virtual void doeDing() = 0; }; class B : public A { public: void doeDing() {... } };

23  We kunnen geen objecten van een abstracte class instancieren  We kunnen wel het pointer type van de class gebruiken om naar child types te wijzen A *a = new B();

24  Denk eraan, in C++ is alles pass-by-value! ◦ Stel, we maken een vector aan ◦ Binnen de vector wordt ruimte gemaakt voor A objecten ◦ Stel dat we nu een B object in deze vector gooien ◦ Stel nu ook dat B meer data bevat dan A (bijvoorbeeld extra member variables) ◦ Alleen sizeof(A) aan data word opgeslagen! Het B object word ergens afgekapt (Slicing) !

25  Om Slicing op te lossen moeten we dus de variable loskoppelen van de grootte van het object  Pointers! ◦ In het vorige voorbeeld hadden we dus een vector moeten gebruiken

26  Polymorphisme werkt hand in hand met pointers  Bij het aanmaken van een polymorpisch object wordt ook de zogenaamde ‘virtual table’ aangemaakt  De ‘virtual table’ bevat de pointers naar de correcte functions  Als een methode wordt aangeroepen wordt de correcte functie uit de ‘virtual table’ opgehaald

27