namespace lang_struct_vcall_in_ctor {

  // Code with explicit inline constructor invocation. 

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

  class DerivedExplicit : BaseExplicit {
      int i;
      virtual void virtual_setup(void) override {i=5;}
  };

  BaseExplicit * use_base_explicit(void){
      BaseExplicit *be = new BaseExplicit();           // Explicit invocation of inline constructor.
      return be;
  }

  // Code with implicit inline constructor invocation. 

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

  class DerivedImplicit : BaseImplicit {
      int i;
      virtual void virtual_setup(void) override {i=5;}
    public:
      int value(void){
          return i;               // 'Uninitialized Variable' warning issued here 
                                  //   - when use_derived_implicit() calls d.value(), the issues with the virtual
                                  //     call in the constructor mean that d.i has NOT actually been initialized.
      }
  };

  int use_derived_implicit(void){
      DerivedImplicit d;                               // Implicit invocation of inline BaseImplicit constructor
                                                       // (and then DerivedImplicit constructor).
      return d.value();
  }
}