C++ polymorphism/inheritance question: Redefinition of base functions vs virtual functions

Question

I know that derived classes can simply "redefine" base class member functions, and that when that function of a derived class object is called, the function defined in the derived class is used, but... Doesn't this render the "virtual" keyword redundant? I have read of some obviously significant differences between these two cases (ie: if you have a base class pointer pointing to a derived class and you call a function, if it is virtual the derived class function will be called, but if not, the base class function will be called).

Put another way, what is the purpose of being able to redefine member functions as non-virtual functions, and is this a commonly used practice?

Personally, it seems to me like it would just get very confusing.

Thanks!

Answer 1

The most common approach on the most common OOP languages (Java, SmallTalk, Python, etc.) is to have, by default, every member function as virtual.

The drawback is that there is a small performance penalty for every time a virtual call is made. For that reason, C++ lets you choose if you want your methods defined as virtual, or not.

However, there is a very important difference between a virtual and a non-virtual method. For example:

class SomeClass { ... };
class SomeSubclassOfSomeClass : public SomeClass { ... };
class AnotherSubclassOfSomeClass : public SomeClass { ... };

SomeClass* p = ...;

p->someVirtualMethod();

p->someNonVirtualMethod();

The actual code executed when the someVirtualMethod call is made depends on the concrete type of the referenced pointer p, depending entirely on SomeClass subclasses redefinition.

But the code executed on the someNonVirtualMethod call is clear: always the one on SomeClass, since the type of the p variable is SomeClass.

Answer 2

It sounds like you already know the difference between virtual and non-virtual methods, so I won't go into that as others have. The question is, when would a non-virtual method be more useful than a virtual one?

There are cases where you don't want the overhead of having a vtable pointer included in every object, so you take pains to make sure there are no virtual methods in the class. Take for example a class that represents a point and has two members, x and y - you might have a very large collection of these points, and a vtable pointer would increase the size of the object by at least 50%.