Question

I have just created 2 pointers which has undefined behavior and try to invoke a class member function which has no object created ?

I don’t understand this?

#include<iostream>

using namespace std;

class Animal
{
public:
  void talk()
  {
    cout<<"I am an animal"<<endl; 
  }
};

class Dog : public Animal
{  
public:
  void talk()
  {
    cout<<"bark"<<endl; 
  }
};

int main()
{
  Animal * a;
  Dog * d;

  d->talk();
  a->talk();  
} 

Answer 1

A) It’s undefined behavior. Any behavior may happen.

B) Since you’re not calling a virtual method, it’s pretty easy to explain why the undefined behavior actually does this (and I’ve tested this under just about every compiler I could find).

In C++, calling a member method is equivalent (in practice if not in definition) of calling a member with a hidden ‘this’ variable. If the method is virtual, it has to go through the vftable, but not for a non-virtual method.

So

Foo::Bar(){}

is the rough equivalent of

Foo_Bar(Foo *this){}

and in the calling code

Foo *foo = new Foo();
foo->bar();

the second line is roughly the moral equivalent of

Foo_Bar(foo);

Now, there’s some simplification going on here, and as I said, some of this may be implementation detail rather than specification. However, the behavior holds true (though relying upon it is an error).

But, given the preceding, look at an implementation:

void Foo::Bar(){printf("Hello, world!\n");}

and calling code:

Foo *foo = 0;
foo->Bar();

As we’ve said, this is roughly equivalent (since we’re non-virtual) to:

Foo *foo = 0;
Foo::Bar(foo);

Which means that we’re calling the equivalent of the following method:

void Foo_Bar(Foo* this)
{ printf("Hello, world\n"); }

Now, given this method, we’re not actually dereffing the this pointer! So, it’s pretty clear why, in this case, the method will work and not fail.

The practical upshot of this is that calling non-virtual methods on a null pointer, where the method doesn’t deref an a member, will generally result in this observed behavior. But, relying upon any undefined behavior is, basically, evil.