University:
Boston University
Course:
MET CS 201 | Introduction to Programming
Academic year:

2023
Views:

194

Pages:

15
Author:

Deja Hood

A new constructor is needed.  A square is, of course, just a rectangle with equal length and width.  The area can be calculated the same way as a rectangle.  Our Square class therefore needs just one value to initialize it and it can re-use the Rectangle.Area() method for its area.  Go ahead and try it:  Add an argument to the default constructor in square.h  Update the constructor in square.cpp to do…?  Remember Square can access the public members and methods in its superclass Solution 1 #ifndef SQUARE_H #define SQUARE_H #include "rectangle.h" class Square : public Rectangle { public: Square(float width); virtual ~Square(); #include "square.h" Square::Square(float length) : m_width(width), m_length(length) {}   Square can access the public members in its superclass. Its constructor can then just assign the length of the side to the Rectangle m_width and m_length.  This is unsatisfying – while there is nothing wrong with this it’s not the OOP way to do things.  Why re-code the perfectly good constructor in Rectangle? protected: private: }; #endif // SQUARE_H The delegating constructor  C++11 added an additional alternate constructor syntax.  Using member initialization lists you can call one constructor from another. Here call a constructor within a class.  Even better: with member initialization lists C++ can call superclass constructors! Rectangle::Rectangle(float width) : Rectangle(width,7) {} Solution 2 #ifndef SQUARE_H #define SQUARE_H #include "rectangle.h" class Square : public Rectangle { public: Square(float width); virtual ~Square(); #include "square.h" Square::Square(float length) : Rectangle(length, length) {}  Square can directly call its superclass constructor and let the Rectangle constructor make the assignment to m_width and m_float.  This saves typing, time, and reduces the chance of adding bugs to your code. protected: private: };  The more complex your code, the more compelling this statement is. #endif // SQUARE_H  Code re-use is one of the prime reasons to use OOP. Trying it out in main()  What happens behind the scenes when this is compiled…. #include using namespace std; #include "square.h" sQ.Area() int main() { Square sQ(4) ; Square class does not implement Area() so compiler looks to superclass // Uses the Rectangle Area() method! cout << sQ.Area() << endl ; Finds Area() in Rectangle class. return 0; } Inserts call to Rectangle.Area() method in compiled code. More on Destructors  When a subclass object is removed from memory, its destructor is called as it is for any object.  Its superclass destructor is than also called .  Each subclass should only clean up its own problems and let superclasses clean up theirs. Square object is removed from memory ~Square() is called ~Rectangle() is called The formal concepts in OOP Polymorphism  Next up: Polymorphism Encapsulation OOP Inheritance Abstraction Using subclasses  A function that takes a superclass argument can also be called with a subclass as the argument.  The reverse is not true – a function expecting a subclass argument cannot accept its superclass.  Copy the code to the right and add it to your main.cpp file. void PrintArea(Rectangle &rT) { cout << rT.Area() << endl ; } int main() { Rectangle rT(1.0,2.0) ; Square sQ(3.0) ; PrintArea(rT) ; PrintArea(sQ) ; } The PrintArea function can accept the Square object sQ because Square is a subclass of Rectangle. Overriding Methods  Sometimes a subclass needs to have the same interface to a method as a superclass with different functionality.  This is achieved by overriding a method.  Overriding a method is simple: just reimplement the method with the same name and arguments in the subclass. In C::B open project: CodeBlocks Projects  Part 2  Virtual Method Calls class Super { public: void PrintNum() { cout << 1 << endl ; } } ; class Sub : public Super { public: // Override void PrintNum() { cout << 2 << endl ; } } ; Super sP ; sP.PrintNum() ; // Prints 1 Sub sB ; sB.PrintNum() ; // Prints 2 Overriding Methods  Seems simple, right?  To quote from slide 10 in Part 1 of this tutorial, C++: “Includes all the subtleties of C and adds its own”  Overriding methods is one of those subtleties. class Super { public: void PrintNum() { cout << 1 << endl ; } } ; class Sub : public Super { public: // Override void PrintNum() { cout << 2 << endl ; } } ; Super sP ; sP.PrintNum() ; // Prints 1 Sub sB ; sB.PrintNum() ; // Prints 2 How about in a function call…  Given the class definitions, what is happening in this function call?  Using a single function to operate on different types is polymorphism. “C++ is an insult to the human brain” – Niklaus Wirth (designer of Pascal) class Super { public: void PrintNum() { cout << 1 << endl ; } } ; class Sub : public Super { public: // Override void PrintNum() { cout << 2 << endl ; } } ; void FuncRef(Super &sP) { sP.PrintNum() ; } Super sP ; Func(sP) ; Sub sB ; Func(sB) ; // Prints 1 // Hey!! Prints 1!! Type casting void FuncRef(Super &sP) { sP.PrintNum() ; }  The Func function passes the argument as a reference (Super &sP).  What’s happening here is dynamic type casting, the process of converting from one type to another at runtime.  Same mechanism as the dynamic_cast function  The incoming object is treated as though it were a superclass object in the function.  When methods are overridden and called there are two points where the proper version of the method can be identified: either at compile time or at runtime. Virtual methods  When a method is labeled as virtual and overridden the compiler will generate code that will check the type of an object at runtime when the method is called.  The type check will then result in the expected version of the method being called.  When overriding a virtual method in a subclass, it’s a good idea to label the method as virtual in the subclass as well.  …just in case this gets subclassed again! class SuperVirtual { public: virtual void PrintNum() { cout << 1 << endl ; } } ; class SubVirtual : public SuperVirtual { public: // Override virtual void PrintNum() { cout << 2 << endl ; } } ; void Func(SuperVirtual &sP) { sP.PrintNum() ; } SuperVirtual sP ; Func(sP) ; // Prints 1 SubVirtual sB ; Func(sB) ; // Prints 2!! Early (static) vs. Late (dynamic) binding  What is going on here?  Leaving out the virtual keyword on a method that is overridden results in the compiler deciding at compile time which version (subclass or superclass) of the method to call.  This is called early or static binding.  At compile time, a function that takes a superclass argument will only call the non-virtual superclass method under early binding.  Making a method virtual adds code behind the scenes (that you, the programmer, never interact with directly)  A table called a vtable for each class is created that tracks all the overrides of the virtual method.  Lookups in the vtable are done to figure out what override of the virtual method should be run.  This is called late or dynamic binding.  There is a small performance penalty for late binding due to the vtable lookup.  This only applies when an object is referred to by a reference or pointer. Behind the scenes – vptr and vtable Func(SuperVirtual &sP)  C++ classes have a hidden pointer (vptr) generated that points to a table of virtual methods associated with a class (vtable).  When a virtual class method (base class or its subclasses) is called by reference when the programming is running the following happens:  The object’s class vptr is followed to its class vtable  The virtual method is looked up in the vtable and is then called.  One vptr and one vtable per class so minimal memory overhead  If a method override is non-virtual it won’t be in the vtable and it is selected a compile time. sP is a reference to a… SuperVirtual SubVirtual SuperVirtual’s vptr SubVirtual’s vptr Vtable Vtable & SuperVirtual::PrintNum() & SubVirtual::PrintNum()