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.

Answer: 
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.
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"
> 
> 
>