>I need an example of how its done in C++
Inheritance in C++ is far more complicated than Java.

>So that's why, dave said he didn't really understand it!
Well, inheritance in C++ has a lot of facets to it. There are multiple ways of inheriting, for example. You can have public inheritance, private inheritance, protected inheritance, each of them can be virtual, and they can all be mixed and matched using multiple inheritance. Compare that with Java.

>What is a Virtual Function?
A virtual function is a member function that can be redefined in derived classes to do something different than the base class. It's different from how non-virtual functions in derived classes override their base class counterparts because using virtual functions you can create behavioral polymorphism. That's a fancy way of saying that you can create an object of the derived class, assign it to a pointer or reference to the base class, and the redefined member function will be called instead of the base class function:

C++ Syntax (Toggle Plain Text)

class Base {
public:
  void f1() { cout<<"Base class"<<endl; }
  virtual void f2() { cout<<"Base class"<<endl; }
};
 
class Derived: public Base {
public:
  void f1() { cout<<"Derived class"<<endl; }
  void f2() { cout<<"Derived class"<<endl; }
};
 
int main()
{
  Base a;
  Derived b;
  Base& r = b;
}

class Base { public: void f1() { cout<<"Base class"<<endl; } virtual void f2() { cout<<"Base class"<<endl; } }; class Derived: public Base { public: void f1() { cout<<"Derived class"<<endl; } void f2() { cout<<"Derived class"<<endl; } }; int main() { Base a; Derived b; Base& r = b; }

In the above code, if you say a.f1(), you'll get "Base class" as expected. If you say a.f2(), you'll also get "Base class" as expected. The same goes for b, b.f1() and b.f2() both print "Derived class". The fun part comes when you call f1 and f2 from r.

C++ will look at the type of the object itself when calling member functions unless the member function is virtual. That is, because r is a reference to Base, the Base member functions will be called instead of the Derived member functions. You can verify that by calling r.f1(). It prints "Base class". r's static type is reference to Base.

Now, since r actually references an object of Derived, the dynamic type of r is Derived. This is where virtual member functions come in. A virtual member function will be called on the dynamic type of an object rather than the static type, so calling r.f2() will print "Derived class" because f2 is virtual and r's dynamic type is Derived.

That's really all a virtual function is; it's a way to implement behavioral polymorphism.

>So that's why, dave said he didn't really understand it!
Well, inheritance in C++ has a lot of facets to it. There are multiple ways of inheriting, for example. You can have public inheritance, private inheritance, protected inheritance, each of them can be virtual, and they can all be mixed and matched using multiple inheritance. Compare that with Java.

>What is a Virtual Function?
A virtual function is a member function that can be redefined in derived classes to do something different than the base class. It's different from how non-virtual functions in derived classes override their base class counterparts because using virtual functions you can create behavioral polymorphism. That's a fancy way of saying that you can create an object of the derived class, assign it to a pointer or reference to the base class, and the redefined member function will be called instead of the base class function:

(Toggle Plain Text)

class Base {
public:
  void f1() { cout<<"Base class"<<endl; }
  virtual void f2() { cout<<"Base class"<<endl; }
};

class Derived: public Base {
public:
  void f1() { cout<<"Derived class"<<endl; }
  void f2() { cout<<"Derived class"<<endl; }
};

int main()
{
  Base a;
  Derived b;
  Base& r = b;  //Does that mean that Base& in now an alias for the class called Bass or r is now the alias for call by reference purposes?
}

class Base { public: void f1() { cout<<"Base class"<<endl; } virtual void f2() { cout<<"Base class"<<endl; } }; class Derived: public Base { public: void f1() { cout<<"Derived class"<<endl; } void f2() { cout<<"Derived class"<<endl; } }; int main() { Base a; Derived b; Base& r = b; //Does that mean that Base& in now an alias for the class called Bass or r is now the alias for call by reference purposes? }

In the above code, if you say a.f1(), you'll get "Base class" as expected. If you say a.f2(), you'll also get "Base class" as expected. The same goes for b, b.f1() and b.f2() both print "Derived class" (I'm with you so far!). The fun part comes when you call f1 and f2 from r.

I'm lost Na let me keep reading though!

C++ will look at the type of the object itself when calling member functions unless the member function is virtual. That is, because r is a reference to Base, the Base member functions will be called instead of the Derived member functions (STOP STOP STOP!...then shouldn't r = a, I'm confused). You can verify that by calling r.f1(). It prints "Base class". r's static type is reference to Base.

Now, since r actually references an object of Derived, the dynamic type of r is Derived (Huh?...Okay so rvalue r is now b which is a memeber of the class Derived). This is where virtual member functions come in (LOL, I see now that my interviewer was WAY ahead of me!). A virtual member function will be called on the dynamic type of an object rather than the static type, so calling r.f2() will print "Derived class" because f2 is virtual and r's dynamic type is Derived.

That's really all a virtual function is; it's a way to implement behavioral polymorphism.

>1. What is polymorphism? Does it mean many Morphs?
Yes.

>2. I don't see static or dynamic anywhere in your code, how can I tell which type is which?
The static type is how you declared it. r is a reference to Base because it was declared:

C++ Syntax (Toggle Plain Text)

Base& r;

Base& r;

The dynamic type is what the object really is. r was initialized with a Derived object, so the dynamic type is Derived.

>3. This is by far the most confusing aspect of C++ we've discussed
Yes. Yes, it is. The good news is that you can do a lot of useful programming without touching inheritance.

>what is your definition of a dynamic or static object?
Static or dynamic type. A static type is the type that you declare an object as:

C++ Syntax (Toggle Plain Text)

int i; // Static type is int
string s; // Static type is string

int i; // Static type is int string s; // Static type is string

The dynamic type is determined with what is called dynamic binding, or late binding. Your book may talk about them when referring to virtual member functions. The best explanation of dynamic binding I can think of right now is a costume. A wolf puts on a sheep costume. The wolf looks like a sheep, but it's actually a wolf:

C++ Syntax (Toggle Plain Text)

Sheep *kid = new Wolf;

Sheep *kid = new Wolf;

kid's static type is Sheep, but it's dynamic type is Wolf. kid can go anywhere that a Sheep can, so it's polymorphic.