Is it valid to "hide" a base class virtual function by making it pure virtual in derived classes?

Question

Consider the example:

#include <iostream>

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

void A::f()
{
    std::cout << "f() from A\n";
}

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

class C: public B {
    public:
    void f();
};

void C::f()
{
    std::cout << "f() from C\n";
}

int main()
{
    C o;
    o.f();
}

A::f() implementation is "hidden" from class C, which provides its own implementation for f() - effectively making A::f() more or less pointless. I see little value in such class hierarchy design, but my question whether this is a valid C++ or just "works" (such as undefined behaviours)?

Answer 1

It is clearly allowed and supported by the standard (cf, for example, this online C++ standard draft), and thus clearly not undefined behaviour:

10.4 Abstract classes

5 [ Note: An abstract class can be derived from a class that is not abstract, and a pure virtual function may override a virtual function which is not pure. — end note ]

The effect is that your class B becomes abstract and any subclass - if it shall not be abstract, too - must define f() then; the implementation in class A can still be invoked through A::f(), such that it is - from the perspective of reusing the implementation - not pointless.

Answer 2

This will safely achieve the goal of requiring the author of C to provide an implementation for f().

I would query why this is needed — if the base implementation is not "valid" in your design then why does it exist, and/or why is it virtual?

They can still invoke A::f(), anyway, so whether this can be deemed "hiding" is open to debate.