Missunderstanding in virtual function call

Question

I have the following code, and I don't understand why it calls the A class function instead of B class function. Could someone tell me why??

#include<iostream>
using namespace std;
class A{
public:
    virtual void f(int n){
        f(n);
        cout << "A";
    }
};
class B :public A{
public:
    virtual void f(float f){
        cout << "B";
    }
};
int main(){
    A*p= new B;

    p->f(5.1);



}

I seem to remember a `override` keyword that is also used in C++. — Lasse V. Karlsen, Sep 12 '15 at 20:32
maybe this other answer helps http://stackoverflow.com/questions/2238928/why-do-we-actually-have-virtual-functions — jfplataroti, Sep 12 '15 at 20:34
if you change the function in B to `virtual void f(int f)` it will override the function in A and print "B" as expected. — Miki, Sep 12 '15 at 21:01
Miki but why it calls the A::f(int n) function instead of B::f(float n)?? — Mr. Hello_world, Sep 12 '15 at 21:03
Because p is of type `A`, and there's no function in `B` that overrides `f` — Miki, Sep 12 '15 at 21:07

score 1 · Answer 1 · answered Sep 12 '15 at 23:01

1

These are completely different functions. A function is identified by its name and its arguments. You have no overriding here: you have two distinct functions.

If you'd used the override keyword, the compiler would have immediately told you this.

answered Sep 12 '15 at 23:01

Lightness Races in Orbit

378,754
76
643
1,055

score 0 · Answer 2 · answered Sep 12 '15 at 22:34

I Modified your Code slightly as under. And I get the desired result. i.e.: when accessing a derived class reference from a base class pointer I get the compiler to map my function call correctly to the derived class' implementation.

I guess the following facts apply:

A derived class would have to first implement(override: which doesn't say change the signature) the Virtual functions defined by the base class to be able to call/access them polymorphically.
After a base class has implemented the virtual functions they can very well be overloaded.
One other thing, If we see the VTable creation mechanism, Only when the derived class implements a virtual function defined at a base calss an entry for the same function name would be made. Otherwise the pointer A is still a map of the Class A and has no idea how to resolve the call to and ends up in implicitly casting the 5.1 double to int according to the implementation of function f in class A. this is pretty much what I mentioned in point#1
virtual functions and pure virtual functions are a means of providing/creating an interface which can be shared across different layers of your software, where the you simply share the interface and the can hide the implementation from the user. So having same function name/ interfaces defined by two classes would only cause more confusion.
```
#include<iostream>
using namespace std;
class A{
    public:
      virtual void f(int n){ cout << "A" << endl; }
};

class B :public A{
    public:
      void f(int f){ cout << "B" << endl;   }
      void f(float f){ cout << "B" << endl; }
};
int main(){
    A*p= new B;
    p->f(5.1);
}
```

Since there are lot of pros in this forum, ff there is anything incorrect in my answer, please put in your comments. Thanks.

@lightness: OK, for overloading to work, we need a functions in the same scope. Now we also wanted that the overloaded function be called polymorphically . To obtain that we first need to override the original function f() declared in the base class (this would create the instance of f() in b and add a vtable entry such that polymorphic calls are possible). Once that is done you'd be able to polymorphically call any overloaded instance of f(). — abhishek chattopadhyay, Sep 16 '15 at 15:55

Missunderstanding in virtual function call

2 Answers2