#dynamic binding

Virtual functions in C++

Virtual functions

Virtual functions are special type of member functions (MFs) which are defined in base class and are redefined in derived classes. Virtual functions perform specific tasks of simplifying function calls and act as a vehicle for induction of polymorphism in OOP. A virtual function is declared by placing the keyword virtual before the declaration of member function in the base class

The C++ Virtual Keyword: Nothing Dynamic or RunTime about it

What if I tell you that we were learning it wrong?

class Animal {                 public void WhoIAm()                 {                                 System.out.println("I Am Animal");                 } } class Dog extends Animal {                 public void WhoIAm()                 {                                 System.out.println("I Am Dog");                 } } class Cat extends Animal {                 public void WhoIAm()…

JAVA : Post 1.4 : Binding

In the previous post a brief introduction to polymorphism was given.We also discussed that polymorphism are of two types Static Polymorphism and Dynamic Polymorphism. In order to avoid confusion Static Polymorphism is also called as Static binding  or Early Binding and Dynamic Polymorphism is also called Dynamic binding or Later Binding.

As mentioned before in the initial posts i will be…

#include #include using namespace std; // class declaration for the base class class One { protected: double a; public: One(double = 2); // constructor double f1(double); double f2(double); };// class implementation for One One::One(double val) // constructor { a = val; } double One::f1(double num) { return (num / 2); } double One::f2(double num) { return (pow(f1(num), 2)); // square the result of f1( ) } class Two : public One { public: double f1(double); // this overrides class One's f1( ) // f2( ) function unchanged! }; double Two::f1(double num) { return (num / 3); } int main() { One object_1; Two object_2; // call f2( ) using a base class object call cout << "The computed value using a base class object call is " << object_1.f2(12) << endl; // call f2( ) using a derived class object call cout << "The computed value using a derived class object call is " << object_2.f2(12) << endl; return 0; }

Output:

The computed value using a base class object call is 36 

The computed value using a derived class object call is 36 

If you modify the definition of class One,which is adding a keyword virtual, as follows.

class One { protected: double a; public: One(double = 2); // constructor virtual double f1(double); // a member function double f2(double); // another member function };

Output:

The computed value using a base class object call is 36

I've been reviewing some of my C++ concepts, and I came across my good ol' friend, polymorphism. Polymorphism is what allows C++ programs to decide the kind of functionality to use during runtime.

Say we have an abstract base class, called "vehicle". We call vehicle abstract because we would never instantiate any objects of type "vehicle". We tell the compiler that we can never instantiate an object of type "vehicle" by making at least one of its methods a pure virtual function - say, a method called "goFast". Imagine also that we have two classes that inherited from "vehicle", called "AcuraIntegra", and "SuperFastSpeedboat". In each of the two child classes, we define the "goFast" method - one method of "goFast" will apply to how an "AcuraIntegra" would go fast, and the same for "SuperFastSpeedboat".

Next, somewhere in our code (where we're allowed), we would create a pointer of type "vehicle", and also we would instantiate an AcuraIntegra and a SuperFastSpeedboat. It would be nice to be able to point to a type of vehicle, and just do the "goFast" method, without knowing before compiling the kind of vehicle to which we were pointing - allowing for flexibility. Polymorphism is that thing that allows us to do this magic.

But there's always a price to pay. Polymorphism is implemented using an array of function pointers (the vtable), and there's one for each class that has at least one virtual function. Note that there only needs to be one vtable for the many instantiated objects of the type of class that has at least one virtual function, but this vtable does take up space in process memory. Polymorphism also requires that each object have a pointer to the vtable, which also takes up space in process memory. Another price to pay is that polymorphism needs to use extra instructions in order to be able to look up the proper function to use for the type of data that is being pointed to by the pointer of the abstract type - this takes time.

So, it is always good to think about a functionality's advantages and the price we pay for having those advantages. Depending on what we'll be using it for, perhaps we'll feel alright paying for it. I suppose polymorphism's overhead is one reason why C is usually preferred over C++ when it comes to embedded applications.

Sources:

1. "Dynamic Binding C++". Schmidt, D.

http://www1.cse.wustl.edu/~schmidt/PDF/C++-dynamic-binding4.pdf

2. "C++ Performance Tips". Gilpin, A.