namespace lang_struct_vcall_in_dtor {

  // Code with implicit inline destructor invocation. 

  class BaseExplicit {
      virtual void virtual_cleanup(void) {}
    public:
      ~BaseExplicit() {
          this->virtual_cleanup(); // 'Virtual Call in Destructor' warning issued here.
                                   //   This call to virtual_cleanup() will always invoke BaseExplicit::virtual_cleanup(),
                                   //   which is probably not what the author intends.
      }
  };

  class DerivedExplicit : BaseExplicit {
      int  *iptr;
      virtual void virtual_cleanup(void) override {delete iptr;}
    public:
      DerivedExplicit() {iptr = new int;}
  };

  void use_base_explicit(BaseExplicit *be){
      delete be;                                        // Explicit invocation of inline destructor.
  }

  // Code with implicit destructor invocation. 

  class BaseImplicit {
      virtual void virtual_cleanup(void) {}
    public:
      ~BaseImplicit() {
          this->virtual_cleanup(); // Two 'Virtual Call in Destructor' warnings issued here.
                                   // - one for the virtual call in BaseImplicit::~BaseImplicit()
                                   // - one for the virtual call in DerivedImplicit::~DerivedImplicit()
      }
  };

  class DerivedImplicit : BaseImplicit {
      int *iptr;
      virtual void virtual_cleanup(void) override {delete iptr;}
    public:
        DerivedImplicit() {iptr = new int;  *iptr=5;}
        int value(void){return *iptr;}
  };

  int use_derived_implicit(void){
      DerivedImplicit di;
      return di.value();
                                                        // Implicit invocation of inline DerivedImplicit destructor
                                                        // (and then BaseImplicit destructor) when di goes out of scope.
  }
}