I have been getting attorney at law with my colleagues whether to prefix overridden techniques using the virtual keyword, or limited to the coming initially from base class.

I am inclined to prefix all virtual techniques (that's, techniques including a vtable research) using the virtual keyword. My rationale is threefold:

  1. Considering the fact that C++ lacks an override keyword, the existence of the virtual keyword a minimum of notifies you that the technique involves a research and could theoretically be overridden by further areas of expertise, or might be known as via a pointer to some greater base class.

  2. Consistently by using this style implies that, if you notice a technique (a minimum of inside our code) without the virtual keyword, you are able to initially assume that it's neither based on basics nor specialized in subclass.

  3. If, through some error, the virtual were taken off IFoo, all children will still function (CFooSpecialization::DoBar would still override CFooBase::DoBar, instead of simply hiding it).

The argument from the practice, when i understood it, was, "But that method is not virtual" (that we believe is invalid, and borne from the misunderstanding of virtuality), and "After I begin to see the virtual keyword, I expect which means someone is drawing from this, and search around on their behalf.Inch

The hypothetical classes might be spread across several files, and you will find several areas of expertise.

class IFoo 

class CFooBase : public IFoo 

class CFooSpecialization : public CFooBase 

Stylistically, can you take away the virtual keyword in the two derived classes? If that's the case, why? What exactly are Stack Overflow's ideas here?

I completely accept your rationale. It is a good indication the method may have dynamic dispatch semantics when known as. The "that method is not virtual" argument that you simply co-worker is applying is totally bogus. He's confused the concepts of virtual and pure-virtual.

Adding virtual doesn't have a substantial impact in either case. I am inclined to prefer it but it's actually a subjective problem. However, should you make certain to make use of the override and sealed key phrases in Visual C++, you'll obtain a significant improvement in capability to catch errors at compile time.

I range from the following lines during my PCH:

#if _MSC_VER >= 1400

#define OVERRIDE override

#define SEALED sealed


#define OVERRIDE

#define SEALED


I'd will not use any syntax the compiler will let me omit. With that said, area of the style of C# (so that they can improve over C++) ended up being to require overrides of virtual techniques to become called "override", which appears to become a reasonable idea. My problem is that, becasue it is completely optional, it is just dependent on time before someone omits it, by then you will have become in to the practice of expecting overrides to become have "virtual" specified. Maybe it is best to just live inside the restrictions from the language, then.

A function when a virtual always an online.

So the point is when the virtual keyword sits dormant within the subsequent classes, it doesn't avoid the function/method from being 'virtual' i.e. be overridden. The projects which i labored-in, had the next guideline that we somewhat loved :-

  • When the function/method should really be overridden always employ the 'virtual' keyword. This is particularly true when utilized in interface / base classes.
  • When the derived class should really be sub-categorised further explicity condition the 'virtual' keyword for each function/method that may be overridden.
  • When the function/method within the derived class isn't said to be sub-categorised again, then your keyword 'vitual' will be said showing the function/method was overridden but you will find no further classes that override it again. This ofcourse doesn't prevent someone from overriding within the derived class unless of course the category is created final (non-derivable), however it signifies the technique is not said to be overridden. Ex: /*virtual*/ void guiFocusEvent()