title: Requiring overridden virtual functions to call base implementations
body: <p>Within a C++ class hierarchy, is it possible to enforce a requirement that a particular virtual function always call its base class's implementation also? (Like the way constructors chain?)</p>
  
  <p>I'm looking at a case where a deep class hierarchy has some common interface functions which each child overrides. I'd like each derived class' override to chain through to the base class. It's straightforward to do this explicitly with <em>eg</em> the code below, but there's the risk that someone implementing a new derived class might forget to chain through to the base.</p>
  
  <p>Is there some pattern to enforce this, such that the compiler will throw an error if an override fails to chain the base?</p>
  
  <p>So, in</p>
  
  <pre><code>class CAA 
  {
     virtual void OnEvent( CEvent *e ) { 
       // do base implementation stuff;
     }
  }
  
  class CBB : public CAA
  {
     typedef CAA BaseClass;
     virtual void OnEvent( CEvent *e ) { 
         DoCustomCBBStuff();
         BaseClass::OnEvent( e ); // chain to base
     }
  }
  
  class CCC : public CBB
  {
     typedef CBB BaseClass;
     virtual void OnEvent( CEvent *e ) { 
         Frobble();
         Glorp();
         BaseClass::OnEvent( e ); // chain to CBB which chains to CAA, etc
     }
  }
  
  class CDD : public CCC
  {
     typedef CCC BaseClass;
     virtual void OnEvent( CEvent *e ) { 
         Meep();
         // oops! forgot to chain to base!
     }
  }
  </code></pre>
  
  <p>is there a way, some template trick or syntactic gimmick, to make CDD throw a more obvious error?</p>