Question

Coming from a Java perspective I was surprised to find that you can only override base methods that have the virtual keyword.
In Java you use the final keyword to declare that a method can’t be overridden.

I had the idea in my head that you only rarely want to prohibit overriding so that someone can extend your class how they see fit.

So in C++ if you feel that someone might want to at some stage inherit from your class (maybe years later someone thinks its a cool idea) do you make all your methods virtual?

Or is there some critical reason for wanting to prohibit this in C++ that I am unaware of?

for Reference this was the experimenting i did in each language:

Java

    public class Base {

    void doSomething(){
    System.out.println("Doing the base thing");
    }
    }
    public class Derived extends Base {

    void doSomething(){
    System.out.println("Doing the derived thing");
    }

    public static void main(String... argv){
        Base object = new Derived();
        object.doSomething();
    }
    }

C++

    class Base
    {
    public:
        Base(void);
        ~Base(void);
        virtual void doSomething();
    };

    void Base::doSomething(){
        std::cout << "I'm doing the base thing\n" << std::endl;
    }

    class Derived :
        public Base
    {
    public:
        Derived(void);
        ~Derived(void);
        void doSomething();
    };

    void Derived::doSomething(){
        std::cout << "I'm doing the dervied thing" << std::endl;
    }


    int main(void){

        Base * object = new Derived;

        object->doSomething();
        return 0;

    }

Answer 1

duffymo and Als are steering you in the right direction. I just wanted to comment on one thing you said:

So in C++ if you feel that someone might want to at some stage inherit
from your class (maybe years later someone thinks its a cool idea) do
you make all your methods virtual?

From a software engineering perspective: if you don’t have an immediate use for inheritance and aren’t using interfaces, then I don’t recommend declaring your methods virtual.

Virtual methods come with an ever so slight performance degradation. For non-critical code paths the perf impact is likely negligible. But for class methods that get invoked a lot, it can add up. The compiler can’t do as much inlining and direct linkage. Instead, the virtual method to be invoked has to be looked up in the v-table array at runtime.

When someone on my coding team starts off a design conversation with “someone might want at some point later…” that’s when my “future proofing” anti-pattern alarm goes off. Designing for extensibility is one thing, but “features for the future” should be put off until then.

And besides – the guy years later who thinks it’s a cool idea – Let him be the one to own converting the class methods to be virtual. You’ll be onto bigger projects by then anyway. 🙂