Overriding method shadows overloaded final version

Question

I have the following code:

struct Abs {
    virtual void f(int x) = 0;
    virtual void f(double x) final { std::cout << 2; }
};

struct Sub: public Abs {
    void f(int x) final { std::cout << 1; }
};

Abs is an abstract class which comprises a pure member function void f(int) and its overloaded version void f(double x), which is no longer pure and final. If I try to override void f(int) in the derived struct Sub, it shadows void f(double) and the following main function prints 1, converting 1.01 to int:

int main() {
    Sub x = {};
    x.f(1.01);
    return 0;
}

How do I overcome this problem? Also, why does it work like that?

Answer 1

Given x.f(1.01);, the name f is found in the scope of class Sub, then name lookup stops; the scope of Abs won't be examined. Only Sub::f is put in overload set and then overload resolution is performed.

... name lookup examines the scopes as described below, until it finds at least one declaration of any kind, at which time the lookup stops and no further scopes are examined.

You can use using to introduce the names of Abs into Sub, then Abs::f could be found and take part in overload resolution too.

struct Sub: public Abs {
    using Abs::f;
    void f(int x) final { std::cout << 1; }
};