When To Make Methods Virtual

When to make methods virtual  If a method will be (or might be) overridden in a subclass, make it virtual  There is a minor performance penalty. Will that even matter to you?  i.e. Have you profiled and tested your code to show that virtual method calls are a performance issue?  When is this true?  Almost always! Who knows how your code will be used in the future?  Constructors are never virtual in C++.  Destructors in a base class should always be virtual.  Also – if any method in a class is virtual, make the destructor virtual  These are important when dealing with objects via reference and it avoids some subtleties when manually allocating memory. Why all this complexity? void FuncEarly(SuperVirtual &sP) { sP.PrintNum() ; }      Called by reference – late binding to PrintNum() void FuncLate(SuperVirtual sP) { sP.PrintNum() ; }  Called by value – early binding to PrintNum even though it’s virtual! Late binding allows for code libraries to be updated for new functionality. As methods are identified at runtime the executable does not need to be updated. This is done all the time! Your C++ code may be, for example, a plugin to an existing simulation code. Greater flexibility when dealing with multiple subclasses of a superclass. Most of the time this is the behavior you are looking for when building class hierarchies. Shape virtual float Area() {}  Remember the Deadly Diamond of Death? Let’s explain.  Look at the class hierarchy on the right.  Square and Circle inherit from Shape  Squircle inherits from both Square and Circle  Syntax: class Squircle : public Square, public Circle  The Shape class implements an empty Area() method. The Square and Circle classes override it. Squircle does not.  Under late binding, which version of Area is accessed from Squircle? Square.Area() or Circle.Area()? Square Circle virtual float Area() {…} virtual float Area() {…} Squircle Interfaces Shape  Log Another pitfall of multiple inheritance: the fragile base class problem.  If many classes inherit from a single base (super) class then changes to methods in the base class can have unexpected consequences in the program.  This can happen with single inheritance but it’s much easier to run into with multiple inheritance.  Interfaces are a way to have your classes share behavior without them sharing actual code.  Gives much of the benefit of multiple inheritance without the complexity and pitfalls Square  Circle Example: for debugging you’d like each class to have a Log() method that would write some info to a file.  But each class has different types of information to print!  With multiple inheritance each subclass might implement its own Log() method (or not). If an override is left out in a subclass it may call the Log() method on a superclass and print unexpected information. Interfaces #ifndef SQUARE_H #define SQUARE_H #include "rectangle.h"   An interface class in C++ is called a pure virtual class. It contains virtual methods only with a special syntax. Instead of {} the function is set to 0.    Any subclass needs to implement the methods! Modified square.h shown. What happens when this is compiled? (…error…) include/square.h:10:7: note: because the following virtual functions are pure within 'Square': class Square : public Rectangle, Log ^ include/square.h:7:18: note: virtual void Log::LogInfo() virtual void LogInfo()=0 ;  class Log { virtual void LogInfo()=0 ; }; Once the LogInfo() is uncommented it will compile. class Square : public Rectangle, Log { public: Square(float length); virtual ~Square(); // virtual void LogInfo() {} protected: private: }; #endif // SQUARE_H Putting it all together Shape  Now let’s revisit our Shapes project.  In the directory of C::B projects, open the “Shapes with Circle” project. ??? Rectangle  This has a Shape base class with a Rectangle and a Square  Add a Circle class to the class hierarchy in a sensible fashion. Square  Hint: Think first, code second. Circle New pure virtual Shape class  Slight bit of trickery:  An empty constructor is defined in shape.h  No need to have an extra shape.cpp file if these functions do nothing!  Q: How much code can be in the header file?  A: Most of it with some exceptions. #ifndef SHAPE_H #define SHAPE_H class Shape { public: Shape() {} virtual ~Shape() {}  .h files are not compiled into .o files so a header with a lot of code gets re-compiled every time it’s referenced in a source file. virtual float Area()=0 ; protected: private: }; #endif // SHAPE_H Give it a try  Add inheritance from Shape to the Rectangle class  Add a Circle class, inheriting from wherever you like.  Implement Area() for the Circle  If you just want to see a solution, open the project “Shapes with Circle solved” A Potential Solution Shape  A Circle has one dimension (radius), like a Square.  Would only need to override the Area() method Rectangle  But…  Would be storing the radius in the members m_width and m_length. This is not a very obvious to someone else who reads your code.  Maybe:  Change m_width and m_length names to m_dim_1 and m_dim_2?  Just makes everything more muddled! Square Circle A Better Solution Shape  Inherit separately from the Shape base class  Seems logical, to most people a circle is not a specialized form of rectangle…  Add a member m_radius to store the radius.  Implement the Area() method  Makes more sense!  Easy to extend to add an Oval class, etc. Rectangle Square Circle New Circle class  Also inherits from Shape  Adds a constant value for p  Constant values can be defined right in the header file.  If you accidentally try to change the value of PI the compiler will throw an error. #ifndef CIRCLE_H #define CIRCLE_H #include "shape.h" class Circle : public Shape { public: Circle(); Circle(float radius) ; virtual ~Circle(); virtual float Area() ; const float PI = 3.14; float m_radius ; protected: private: }; #endif // CIRCLE_H #include "circle.h"  circle.cpp  Questions? Circle::Circle() { //ctor } Circle::~Circle() { //dtor } // Use a member initialization list. Circle::Circle(float radius) : m_radius{radius} {} float Circle::Area() { // Quiz: what happens if this line is // uncommented and then compiled: //PI=3.14159 ; return m_radius * m_radius * PI ; } Quiz time! void PrintArea(Shape &shape) { cout << "Area: " << shape.Area() << endl ; }  What happens behind the scenes when the function PrintArea is called?  How about if PrintArea’s argument was instead: int main() { Square sQ(4) ; Circle circ(3.5) ; Rectangle rT(21,2) ; void PrintArea(Shape shape) } // Print everything PrintArea(sQ) ; PrintArea(rT) ; PrintArea(circ) ; return 0; Quick mention…  Aside from overriding functions it is also possible to override operators in C++.  As seen in the C++ string. The + operator concatenates strings: string str = "ABC" ; str = str + "DEF" ; // str is now "ABCDEF"  It’s possible to override +,-,=,<,>, brackets, parentheses, etc.  Syntax: MyClass operator*(const MyClass& mC) {...}  Recommendation:  Generally speaking, avoid this. This is an easy way to generate very confusing code.  The operator= is an exception. Summary   C++ classes can be created in hierarchies via inheritance, a core concept in OOP. Classes that inherit from others can make use of the superclass’ public and protected members and methods     You write less code!  Virtual methods should be used whenever methods will be overridden in subclasses.  Avoid multiple inheritance, use interfaces instead. Subclasses can override a superclass method for their own purposes and can still explicitly call the superclass method. Abstraction means hiding details when they don’t need to be accessed by external code.  Reduces the chances for bugs. While there is a lot of complexity here – in terms of concepts, syntax, and application – keep in mind that OOP is a highly successful way of building programs!