My hope was that a call to obj.f() would result in a call to Base::obj.f() since the derived class doesn't define it, which would then result in a call to Derived::obj.f(0) per the definition in class Base.

What am I doing wrong here? Is there a way to accomplish this? Specifically, I'd like the call to obj.f() to return 10.

(Also please note that I realize I could use a default argument to solve this, but this code is simply a concise example of my issue, so please don't tell me to use default arguments.)

The issue you're running into is orthogonal to pure virtual functions and has to do with how C++ does name resolution in class hierarchies.

When you write

obj.f();

C++ tries to look for a function named f so it knows what to call. Since obj is of type Derived, it starts inside of Derived and looks for a function called f. It ends up finding Derived::f(int), and even though this function takes an argument, C++ thinks this is the method you're trying to call and thus stops looking. The compiler then notices that you're trying to invoke it with no parameters, giving you the error about the function call.

To fix this, you need to tell the C++ compiler that it also needs to try looking for the function Base::f(), which is contained in the base class. To do this, you can change your definition of Derived as follows:

This line using Base::f tells C++ that it should treat functions in Base named f as though they are part of Derived. That way, when the compiler tries looking up a function named f, it finds both Derived::f(int) and Base::f(). The call will then succeed because the compiler can figure out that you're trying to call Base::f() with the code that you've listed.