c++ polymorphism, name resolution for derived class

Question

class Base {
public:
virtual void f(float) { cout << "Base::f(float)\n"; }
};
class Derived : public Base {
public:
virtual void f(int) { cout << "Derived::f(int)\n"; }
};
int main() {
Derived *d = new Derived();
Base *b = d;
b->f(3.14F);
d->f(3.14F);
}

-C++ does not support contravaraint return type, so the f(int) does not override f(float)

-Polymorphism is supported by C++, so both d and b should point to vtable for the derived class.

-vtable for derived class is something like 0: f(float), 1: f(int) etc.

My answer for the question is Base::f(float) is called twice, but the answer is:

Base::f(float) Derived::f(int)

Why is this the case? Does accessing derived class from different pointer enforce certain rules? Far as I am aware, object slicing only occurs when using copy-ctor or copy-assignment, with pointers, they should all point to the same vtable.

cdhowie · Accepted Answer · 2014-11-08T03:53:28.630

4

Methods in different classes do not overload together; defining another f() in Derived prevents the one in Base from being considered during overload resolution.

You need to explicitly bring base definitions into derived classes when you want to add new overloads without hiding the ones defined in base classes.

public:
    using Base::f;

edited Nov 08 '14 at 03:53

answered Nov 08 '14 at 03:36

cdhowie

158,093
24
286
300

Why did `base->f` refer to the base function? – David G Nov 08 '14 at 04:07
I'm also curious to how the pointer affects the name resolution. – legokangpalla Nov 08 '14 at 04:13
@0x499602D2 Because it is accessed through a pointer-to-`Base`, so the compiler does not know that it is actually a `Derived` instance when performing overload resolution. Overload resolution happens at compile time, not at run time. – cdhowie Nov 08 '14 at 04:24

score 1 · Answer 2 · answered Nov 08 '14 at 04:27

My take on this is that there is an implicit conversion of float to int when you call d->f(3.14F)

Your Derivedclass actually has 2 entries for f()

void f(int);
void f(float);

This is confirmed with g++ with the -fdump-class-hierarchy flag. We can see the output as follow :

Vtable for Base
Base::_ZTV4Base: 3u entries
0     (int (*)(...))0
4     (int (*)(...))(& _ZTI4Base)
8     (int (*)(...))Base::f

Vtable for Derived
Derived::_ZTV7Derived: 4u entries
0     (int (*)(...))0
4     (int (*)(...))(& _ZTI7Derived)
8     (int (*)(...))Base::f
12    (int (*)(...))Derived::f

Your Derived class does not touch the f function from the base class since the definitions do not match. The code compiles because there is a implicit conversion which exists between float and int.

Try the following

class Derived : public Base {
public:
virtual void f(std::string) { cout << "Derived::f(string)\n"; }
};

Then this code will not compile as Derived:f(...) will hide the Base::f(...) definition. This is often referred as inheritance shadowing.

So calling b->f(3.14F) will resolve within the Base table and d->f(3.14F) will resolve with the Derived table, which shadows Base.

Looking back, I just realized that the override did not happen should've been obvious as C++ does not support contravariant argument! — legokangpalla, Nov 18 '14 at 12:12

c++ polymorphism, name resolution for derived class

2 Answers2