questions about virtual function in c++

I am a beginner of C++, I am studying virtual func开发者_如何转开发tions these days. There are some questions confuse me a lot.

for example:

class A {
  public:
  virtual void f() {
      //do something; 
  }
}

class B: public A {
   public:
   virtual void f() {
//do something;
}
}

1. class A contains a virtual function f(), and class B inherits it. Inside class B, the function f() is also declared as virtual, so does this mean f() in class B overloads f() in class A? Does it allow classes which inherit B to overload f()? Or does B define a new virtual function which is different from f() in class A?

2. Virtual functions provide a way of overloading methods. If B inherits A and does not declare the f() as virtual, then can a class C which inherits B overload the f() and achieve polymorphism?

---

inside class B, the function f() also be declared as virtual, so does this mean f() in class B overload f() in class A

No, it doesn't overload. It overrides. Also the keyword virtual is optional in class B. B::f() will always be a virtual function, whether you write virtual or not.

The term overload is used when you define a function with same name but different parameter(s). In your case, the signature of the function f is exactly same in both classes, that means it isn't overloading; the derived class basically overrides the base class definition of f().

---

Virtual keyword allows you to override functions not overload them.

Also, the virtual attribute is inherited so virtual keyword is optional for f() in class B.

---

When you declare a function virtual what you are really saying to the compiler is that you want this function to behave in a polymorphic manner. That is, from your example if we have the following:

A* foo = new B();
foo->f();

it will call B's "f" function and not A's "f" function. To take it further, if we have a C which inherits from B like you've said:

class C : public B{}

B* foo = new C();
foo->f():

this calls B's "f". If you had defined it within C, it would have called C's method.

To explain the different behavior between virtual and non-virtual let's take this example:

struct Foo{
    virtual void f();
    void g();
};

struct Bar{
    virtual void f();
    void g();
};

Foo* var = new Bar();
var->f(); //calls Bar's f
var->g(); //calls Foo's g, it's not virtual

make sense?

---

Since A::f is virtual, and B::f has the same signature, it is said that B::f overrides A::f.

Which means:

A * p = new B;
p->f(); // invokes B::f

EDIT: The following is just plain wrong (see the comments):

Since B::f is also virtual, then it would be possible for a child class of B to override it again. If B:f wasn't virtual, than any method with the same signature in a child class would simply shadow it (that is, it would be a different method).

So, the behaviors depends on the parent.