What is the purpose of the final keyword in C 11 for functions

Question

What is the purpose of the final keyword in C  11 for functions  I understand it prevents function overriding by derived classes  but if this is the case  then isn t it enough to declare as non-virtual your final functions  Is there another thing I m missing here

User · Answer

Final cannot be applied to non-virtual functions.

error: only virtual member functions can be marked 'final'

It wouldn't be very meaningful to be able to mark a non-virtual method as 'final'. Given

struct A { void foo(); };
struct B : public A { void foo(); };
A * a = new B;
a -> foo(); // this will call A :: foo anyway, regardless of whether there is a B::foo

a->foo() will always call A::foo.

But, if A::foo was virtual, then B::foo would override it. This might be undesirable, and hence it would make sense to make the virtual function final.

The question is though, why allow final on virtual functions. If you have a deep hierarchy:

struct A            { virtual void foo(); };
struct B : public A { virtual void foo(); };
struct C : public B { virtual void foo() final; };
struct D : public C { /* cannot override foo */ };

Then the final puts a 'floor' on how much overriding can be done. Other classes can extend A and B and override their foo, but it a class extends C then it is not allowed.

So it probably doesn't make sense to make the 'top-level' foo final, but it might make sense lower down.

(I think though, there is room to extend the words final and override to non-virtual members. They would have a different meaning though.)

User · Answer

A use-case for the  final  keyword that I am fond of is as follows      This pure abstract interface creates a way    for unit test suites to stub-out Foo objects class FooInterface   public     virtual void DoSomething     0  private     virtual void DoSomethingImpl     0         Implement Non-Virtual Interface Pattern in FooBase using final     Alternatively implement the Template Pattern in FooBase using final  class FooBase   public FooInterface   public      virtual void DoSomething   final   DoFirst    DoSomethingImpl    DoLast      private      virtual void DoSomethingImpl        left for derived classes to customize          void DoFirst       no derived customization allowed here     void DoLast       no derived customization allowed here either        Feel secure knowing that unit test suites can stub you out at the FooInterface level    if necessary    Feel doubly secure knowing that your children cannot violate your Template Pattern    When DoSomething is called from a FooBase   you know without a doubt that    DoFirst will execute before DoSomethingImpl  and DoLast will execute after  class FooDerived   public FooBase   private      virtual void DoSomethingImpl       customize DoSomething at this location

User · Answer

Final keyword in C   when added to a function  prevents it from being overridden by a base class  Also when added to a class prevents inheritance of any type  Consider the following example which shows use of final specifier  This program fails in compilation    include  lt iostream gt  using namespace std   class Base     public    virtual void myfun   final         cout  lt  lt   myfun   in Base          class Derived   public Base     void myfun           cout  lt  lt   myfun   in Derived n           int main       Derived d    Base  amp b   d    b myfun      return 0      Also    include  lt iostream gt  class Base final       class Derived   public Base       int main       Derived d    return 0

User · Answer

final adds an explicit intent to not have your function overridden  and will cause a compiler error should this be violated   struct A       virtual int foo        1    struct B   A       int foo         As the code stands  it compiles  and B  foo overrides A  foo  B  foo is also virtual  by the way  However  if we change  1 to virtual int foo   final  then this is a compiler error  and we are not allowed to override A  foo any further in derived classes   Note that this does not allow us to  reopen  a new hierarchy  i e  there s no way to make B  foo a new  unrelated function that can be independently at the head of a new virtual hierarchy  Once a function is final  it can never be declared again in any derived class

User · Answer

Nothing to add to the semantic aspects of  final    But I d like to add to chris green s comment that  final  might become a very important compiler optimization technique in the not so distant future  Not only in the simple case he mentioned  but also for more complex real-world class hierarchies which can be  closed  by  final   thus allowing compilers to generate more efficient dispatching code than with the usual vtable approach    One key disadvantage of vtables is that for any such virtual object  assuming 64-bits on a typical Intel CPU  the pointer alone eats up 25   8 of 64 bytes  of a cache line  In the kind of applications I enjoy to write  this hurts very badly   And from my experience it is the  1 argument against C   from a purist performance point of view  i e  by C programmers    In applications which require extreme performance  which is not so unusual for C    this might indeed become awesome  not requiring to workaround this problem manually in C style or weird Template juggling   This technique is known as Devirtualization  A term worth remembering   -   There is a great recent speech by Andrei Alexandrescu which pretty well explains how you can workaround such situations today and how  final  might be part of solving similar cases  automatically  in the future  discussed with listeners    http   channel9 msdn com Events GoingNative 2013 Writing-Quick-Code-in-Cpp-Quickly

User · Answer

What you are missing  as idljarn already mentioned in a comment is that if you are overriding a function from a base class  then you cannot possibly mark it as non-virtual   struct base      virtual void f       struct derived   base      void f   final           virtual as it overrides base  f    struct mostderived   derived        void f                 error  cannot override

User · Answer

It is to prevent a class from being inherited  From Wikipedia      C  11 also adds the ability to prevent inheriting from classes or simply preventing overriding methods in derived classes  This is done with the special identifier final  For example   struct Base1 final       struct Derived1   Base1         ill-formed because the class Base1                                  has been marked final   It is also used to mark a virtual function so as to prevent it from being overridden in the derived classes    struct Base2       virtual void f   final      struct Derived2   Base2       void f       ill-formed because the virtual function Base2  f has                   been marked final        Wikipedia further makes an interesting point      Note that neither override nor final are language keywords  They are technically identifiers  they only gain special meaning when used in those specific contexts  In any other location  they can be valid identifiers    That means  the following is allowed   int const final   0         ok int const override   1      ok

User · Answer

Supplement to Mario Knezovic  s answer   class IA   public    virtual int getNum   const   0      class BaseA   public IA   public   inline virtual int getNum   const final  return           class ImplA   public BaseA         IA  pa            ImplA  impla   static cast lt ImplA  gt  pa      the following line should cause compiler to use the inlined function BaseA  getNum       instead of dynamic binding  via vtable or something     any class subclass of BaseA will benefit from it  int n   impla- gt getNum      The above code shows the theory  but not actually tested on real compilers  Much appreciated if anyone paste a disassembled output

User · Answer

final  also allows a compiler optimization to bypass the indirect call   class IAbstract   public    virtual void DoSomething     0      class CDerived   public IAbstract     void DoSomething   final   m x   1        void Blah  void     DoSomething            with  final   the compiler can call CDerived  DoSomething   directly from within Blah    or even inline  Without it  it has to generate an indirect call inside of Blah   because Blah   could be called inside a derived class which has overridden DoSomething

User · Answer

The final keyword allows you to declare a virtual method  override it N times  and then mandate that  this can no longer be overridden   It would be useful in restricting use of your derived class  so that you can say  I know my super class lets you override this  but if you want to derive from me  you can t     struct Foo      virtual void DoStuff       struct Bar   public Foo      void DoStuff   final     struct Babar   public Bar      void DoStuff       error      As other posters pointed out  it cannot be applied to non-virtual functions   One purpose of the final keyword is to prevent accidental overriding of a method  In my example  DoStuff   may have been a helper function that the derived class simply needs to rename to get correct behavior  Without final  the error would not be discovered until testing

[c++] What is the purpose of the "final" keyword in C++11 for functions?

Examples related to c++

Examples related to c++11

Examples related to final