doc/7.2.final-virtual

   1 final
   2 ~~~~~
   3
   4 lwc implements the attribute 'final'. When a virtual function is declared
   5 final it cannot be overriden in derrived objects. This can lead to certain
   6 optimizations in some -rather rare- cases, where virtual calls are converted
   7 to direct member calls. An example:
   8
   9         class A {
  10         virtual int f ();
  11         };
  12
  13         class B : A {
  14                 int f () final;
  15                 int foo () {
  16                         f ();   // member call!
  17                 }
  18         };
  19
  20 Generally, the approach with auto-functions is more powerful and can
  21 optimize more cases. In the above example, foo could have been declared an
  22 auto function and the f() call would also be a member call in this case.
  23 'final' is helpful in such a situation:
  24
  25         class A {
  26         virtual int f ();
  27         virtual int k ();
  28         };
  29
  30         class B : A {
  31                 int f () final;
  32                 int foo () {
  33                         return f() + k ();
  34                 }
  35         };
  36
  37         class C : B {
  38                 int k ();
  39         };
  40
  41 Here, with 'final' the f() call is a member call and the k() call a virtual
  42 call in 'foo'. final is used to optimize functions which have a pointer to
  43 an object 'B' and below it -- in other words when calling virtual functions
  44 with pointers to derrived objects. This is rather rare in OOP but not
  45 impossible.
  46
  47 B. Virtual inheritance
  48 ~~~~~~~~~~~~~~~~~~~~~~
  49
  50  Just like a non-pure virtual function overrides a pure one, a final virtual
  51 function overrides a non-final one. For example:
  52
  53         class A {
  54                 virtual int f () = 0;
  55         };
  56
  57         class B : virtual A {
  58                 int f ();
  59         };
  60
  61         class C : virtual A {
  62                 int f () final;
  63         };
  64
  65         class D : B, C {
  66                 // C.f wins
  67         };
  68
  69         int main ()
  70         {
  71                 D d;
  72                 d.f ();         // calls C.f() !
  73         }
  74
  75 If both C.f and B.f are final, it is an error.
  76
  77
  78 Finally, final-functions and auto-functions do not stack up.
  79 We could interpret final as a directive to stop automatically
  80 redefining the function, but at the moment 'auto' ignores
  81 'final' and this leads to a reasonable error. Send proposals
  82 to the list.