What's the difference between how virtual and non-virtual member functions are called?

Non-virtual member functions are resolved statically. That is, the member function is selected statically (at compile-time) based on the type of the pointer (or reference) to the object.

In contrast, virtual member functions are resolved dynamically (at run-time). That is, the member function is selected dynamically (at run-time) based on the type of the object, not the type of the pointer/reference to that object. This is called "dynamic binding." Most compilers use some variant of the following technique: if the object has one or more virtual functions, the compiler puts a hidden pointer in the object called a "virtual-pointer" or "v-pointer." This v-pointer points to a global table called the "virtual-table" or "v-table."

The compiler creates a v-table for each class that has at least one virtual function. For example, if class Circle has virtual functions for draw() and move() and resize(), there would be exactly one v-table associated with class Circle, even if there were a gazillion Circle objects, and the v-pointer of each of those Circle objects would point to the Circle v-table. The v-table itself has pointers to each of the virtual functions in the class. For example, the Circle v-table would have three pointers: a pointer to Circle::draw(), a pointer to Circle::move(), and a pointer to Circle::resize().

During a dispatch of a virtual function, the run-time system follows the object's v-pointer to the class's v-table, then follows the appropriate slot in the v-table to the method code.

The space-cost overhead of the above technique is nominal: an extra pointer per object (but only for objects that will need to do dynamic binding), plus an extra pointer per method (but only for virtual methods). The time-cost overhead is also fairly nominal: compared to a normal function call, a virtual function call requires two extra fetches (one to get the value of the v-pointer, a second to get the address of the method). None of this runtime activity happens with non-virtual functions, since the compiler resolves non-virtual functions exclusively at compile-time based on the type of the pointer.

Virtual Table & _vptr

Virtual Table:

Every class that uses virtual functions (or is derived from a class that uses virtual functions) is given it's own virtual table as a secret data member.

This table is set up by the compiler at compile time.

A virtual table contains one entry as a function pointer for each virtual function that can be called by objects of the class.

Virtual table stores NULL pointer to pure virtual functions in ABC.

Virtual Table is created even for classes that have virtual base classes. In this case, the vtable has pointer to the shared instance of the base class along with the pointers to the classe's virtual functions if any.

_vptr :

This vtable pointer or _vptr, is a hidden pointer added by the Compiler to the base class. And this pointer is pointing to the virtual table of that particular class.

This _vptr is inherited to all the derived classes.

Each object of a class with virtual functions transparently stores this _vptr. 

Call to a virtual function by an object is resolved by following this hidden _vptr.

Vtable will be common across objects, _vptr is first member of object space, which points to uniq location -> Vtable

 

 

#include <iostream>

#include <iostream>

using namespace std;

class Test

{

  public:

 

  int data1;

  int data2;

 

  virtual  int fun1()

  {

    cout << this->_vptr << endl ;

  }

 

  Test(){

    cout << this->_vptr << endl ;// pointing to Vtable

    cout << &this->_vptr << endl ; // =  &obj

  }

 

};

int main()

{

  Test obj;

  Test objk;

 

  // _vptr points to vtable which is common across all the objects( address was same for both obj and objk objects _vptr)

 

  cout << "obj's Size = " << sizeof(obj) << endl;

  cout << "obj's Size = " << sizeof(long) << endl;

  cout << &obj << endl << &obj.data1 << endl;

 

  //address difference between obj and obj.data1 address is long which is for _vptr pointer

  return 0;

}

Deadlock Prevention

NECESSARY CONDITIONS

ALL of these four must happen simultaneously for a deadlock to occur:

Mutual exclusion

One or more than one resource must be held by a process in a non-sharable (exclusive) mode.

Hold and Wait

A process holds a resource while waiting for another resource.

No Preemption

There is only voluntary release of a resource - nobody else can make a process give up a resource.

Circular Wait

Process A waits for Process B waits for Process C .... waits for Process A.

 

There are three overall ways to handling deadlocks:

Prevent or avoid deadlocks, so that we don’t get there in the first place

Recover from deadlocks after they happen; of course, this means that we can detect them in the first place

Do nothing…just hope they don’t happen when you need to get something important done!

 

No to Mutual exclusion

• Make resources sharable. Example: share resource by Read only.
• Not a general solution, but useful nevertheless

No to Hold and Wait

1) Only request resources when have none

• • Release resource before requesting next one

2) Atomically acquire all resources at once

• • Single lock to protect all variable

No to No Preemption

• A waiting for something held by B, then take resource away from B and give to A

 

No to Circular Wait

• Impose ordering on resources Give all resources a ranking; must acquire highest ranked first

 

 

Replace Switch-Statement with function pointer EX:-2

#include <iostream>

 

enum{TYPE1,TYPE2,TYPE3,TYPE4,MAX};

 

float Plus (float a, float b) { return a+b; }

float Minus (float a, float b) { return a-b; }

float Multiply(float a, float b) { return a*b; }

float Divide (float a, float b) { return a/b; }

 

float Switch(float a, float b, char opCode)

{

    float result;

    // execute operation

    switch(opCode)

    {

    case '+' : result = Plus (a, b); break;

    case '-' : result = Minus (a, b); break;

    case '*' : result = Multiply (a, b); break;

    case '/' : result = Divide (a, b); break;

    }

    return result;

}

 

 

float (*PFUNC[MAX])(float, float) = { Plus, Minus, Multiply, Divide};

 

float NoSwitch( float a, float b, int type )

{

    float result = PFUNC[ type ] ( a, b );

    return result;

}

 

int main()

{

    std::cout << Switch(2,3,'+') << std::endl;

    std::cout << NoSwitch(2,3,TYPE1) << std::endl;

}

Replace Switch-Statement with function pointer EX:-1

#include <iostream>

float Plus (float a, float b) { return a+b; }

float Minus (float a, float b) { return a-b; }

float Multiply(float a, float b) { return a*b; }

float Divide (float a, float b) { return a/b; }

 

float Switch(float a, float b, char opCode)

{

    float result;

    // execute operation

    switch(opCode)

    {

    case '+' : result = Plus (a, b); break;

    case '-' : result = Minus (a, b); break;

    case '*' : result = Multiply (a, b); break;

    case '/' : result = Divide (a, b); break;

    }

    return result;

}

 

float with_Function_Pointer(float a, float b,float (*pt2Func)(float, float))

{

    float result;

    result = pt2Func(a, b); // call using function pointer

    return result;

}

 

int main()

{

    std::cout << Switch(2,3,'+') << std::endl;

    std::cout << with_Function_Pointer(2,3,Plus) << std::endl;

}