Why does a virtual function get hidden?

Question

I have the following classes:

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


class B : public A{
public:
    void f(int x) {}
};

If I say

B *b = new B();
b->f();

the compiler says error C2660: 'B::f' : function does not take 0 arguments. Shouldn't the function in B overload it, since it is a virtual function? Do virtual functions get hidden like this?

EDIT: I indeed meant to inherit B from A, which shows the same behaviour.

Maybe you would like to derive `B` from `A`? – Sven Marnach Nov 10 '10 at 16:17 — Sven Marnach, Nov 10 '10 at 16:17

Steve Jessop · Accepted Answer · 2010-11-10T16:35:25.313

39

Assuming you intended B to derive from A:

f(int) and f() are different signatures, hence different functions.

You can override a virtual function with a function that has a compatible signature, which means either an identical signature, or one in which the return type is "more specific" (this is covariance).

Otherwise, your derived class function hides the virtual function, just like any other case where a derived class declares functions with the same name as base class functions. You can put using A::f; in class B to unhide the name

Alternatively you can call it as (static_cast<A*>(b))->f();, or as b->A::f();. The difference is that if B actually does override f(), then the former calls the override, whereas the latter calls the function in A regardless.

edited Nov 10 '10 at 16:35

answered Nov 10 '10 at 16:17

Steve Jessop

273,490
39
460
699

That clarifies it! I don't know why I thought that when using `virtual` no hiding should happen. But I see it now. Thanks :) – Oszkar Nov 11 '10 at 07:15
why we can't hide virtual function with different return type? even non-virtual functions allowed different return type. – Asif Mushtaq Mar 12 '16 at 13:14
@UnKnown: With *non*-virtual functions, the functions are completely separate; `A * a = new B(); a.nonVirtualFunction()` will call `A::nonVirtualFunction`, not `B::nonVirtualFunction`. But with *virtual* functions, it will call `B::nonVirtualFunction`, so obviously `B::nonVirtualFunction` has to be at least minimally compatible with `A::nonVirtualFunction`. – ruakh Dec 26 '16 at 17:32

Rod · Answer 2 · 2010-11-10T16:54:09.427

7

Class B does not derive from A so no function F() exists. You probably meant:

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


class B : public A {
public:
    void f(int x) {}
};

Edit: I missed the actual function hiding. See Steve Jessop answer for more thorough explanation.

edited Nov 10 '10 at 16:54

answered Nov 10 '10 at 16:17

Rod

52,748
3
38
55

While well spotted, it does not solve the problem (see Steve Jessops answer). – Björn Pollex Nov 10 '10 at 16:19
LOL like @SteveJessop I jumped on the signature issue, without even noticing `B` doesn't derive from `A`! +1 – wilhelmtell Nov 10 '10 at 16:19
@wilhelmtell: correct, I didn't notice the missing inheritance until Rod pointed it out. – Steve Jessop Nov 10 '10 at 16:22
Indeed, I forgot to write it that way, but Steve Jessop's answer clarified the correct case. – Oszkar Nov 11 '10 at 07:10

score 4 · Answer 3 · answered Nov 10 '10 at 16:19

4

No, and yes, respectively. If you want the overloading behaviour, you need to say

using A::f;

in B.

answered Nov 10 '10 at 16:19

Stuart Golodetz

20,238
4
51
80

1

Indeed, I missed that :) Had it been, though, that's what you'd need to do. – Stuart Golodetz Nov 10 '10 at 19:45
Yes, I meant deriving it. Thanks! – Oszkar Nov 11 '10 at 07:12

Konstantin Burlachenko · Answer 4 · 2015-03-22T14:29:40.260

2

It seems that it is exist rather similar question with answer in Biern Stroustrup's FAQ: http://www.stroustrup.com/bs_faq2.html#overloadderived

As he said:

"In C++, there is no overloading across scopes"

but if you want

"That's easily done using a using-declaration"

edited Mar 22 '15 at 14:29

answered Mar 22 '15 at 14:19

Konstantin Burlachenko

5,233
2
41
40

score 2 · Answer 5 · answered Nov 10 '10 at 16:18

2

B does not derive from A, the correct declaration is:

class B : public A

answered Nov 10 '10 at 16:18

Moo-Juice

38,257
10
78
128

Kelly S. French · Answer 6 · 2010-11-11T15:39:07.020

When the compiler has more than one way to resolve a symbol, it has to choose which one has precedence unless the code tells it otherwise. What you are expecting is the overloading to take precedence over the overriding. (over, over, over, aaaaack! Sorry, got 'over'whelmed).

This example has B inheriting a virtual method in which the subclass provides an overloaded version. Overloads are for methods in the same class using the same method name but different signatures. Since B is a subclass of A, it is overriding f(), which means it cannot also be an overload at the same time. This is why it is being hidden.

For class A, declaring method

virtual void f() {}

as virtual means that method will be resolved using a certain set of rules that are not consistent with your declaration of b.

B *b = new B();

By creating 'b' as an instance of "B", the compiler has no need to use the virtual nature of the method of the same name in "A".

If you had declared 'b' like this

B *b = new A();

then the call b->f(); would indeed refer to the method in A by making use of the virtual resolution.

Why does a virtual function get hidden?

6 Answers6

Linked

Related