私有方法的动态绑定：Java与C ++

Question

This is not allowed in Java:

class A { 
    public void method() {}
}

class B extends A { 
    private void method() {}
}

It generates a compile error:

error: method() in B cannot override method() in A 
attempting to assign weaker access privileges; was public

However, this IS allowed in C++:

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

class B : public A { 
    private:
        void method() {}
};

int main(void) {
    A* obj = new B();
    obj->method(); // B::method is invoked, despite it being private
}

What's the logic behind this behavior in C++?

Answer 1

Remember that the visibility of method is resolved purely at compile-time, C++ has no concept of a runtime verifier. What the compiler sees is a virtual A::method , which is not private. The concrete implementation is declared private, but that is only relevant when this implementation is directly invoked in a manner visible to the compiler, ie if you try to access it directly by calling it through B .

The logic of it is illustrated by the following case: Imagine if B didn't inherit from A publically, but privately — this is allowed in C++, and used when inheritance itself is an implementation detail, such as for a stack class inheriting from vector , but not wanting to expose the vector interface. In that case it would be a feature for B::method to be inaccessible, but A::method working just fine, even if the object is a B instance.

As Kerrek SB said, here Java is protecting you from one class of mistakes, at the cost of removing legitimate options.

Answer 2

As for the virtual private methods part, this allows one to implement the NVI pattern , so that you can do invariant checks or set-up/tear-down in a situation where inheritance is used.

Here is an example with a lock and a postcondition verification:

class base {
public:
    virtual ~base() = default;

    // Calls the derived class' implementation in a thread-safe manner.
    // @return A value greater than 42.
    int function() {
        std::lock_guard<std::mutex> guard(mutex);
        auto result = function_impl();
        assert(result > 42);
        return result;
    }

private:
    std::mutex mutex;
    virtual int function_impl() = 0; 
};

class derived : public base {
private:
    virtual int function_impl() override {
        return 0; // Whoops! A bug!
    }
};

In Java this could be achieved with protected methods, but that would leak implementation details to derived classes of derived classes which might be undesired.

As for the privatising otherwise public members part, if somebody would suddenly make function_impl public in base , it won't break the derived classes. I'm not saying it's a very good idea to do this, but C++ usually just assumes you know what you're doing, hence it's such a flexible language.