Constructor inheritance & polish function

[Kristian]

Let there be classes Base and Derived. Base is the base class of Derived.

There are several constructors in Base. Derived can have constructors as  
follows:

1) Derived has only the default constructor which calls 'Base.this()' if  
it exists.
2) Derived uses the same constructor interface as Base. The constructors  
are not modified in any way (i.e. they simply call the ones in Base).
3) Derived uses the same constructor interface as Base. Some or all of the  
constructers are modified.
4) Derived uses different constructor interface as Base.

To my experience the commonness of the situations is: 2, 3, 4, and 1.


So constructors should be inherited from the base class. For example:

class Base {
     this() {...}
     this(int val) {...}

     void f() {...}
}

class Derived : Base {
     void f() {...}  //overrule a member function
}

void func() {
     Derived obj = new Derived(1);  //calls 'Base.this(int)' (now a compile  
time error)
}

It would make the case 2 breeze to implement!

If you define constructors for Derived, then the ones defined in Base  
should be hidden. The case 1 could be achieved by defining one  
constructor: 'this() {}'.


If there was a polish function (just like one in Qt) which is called after  
a constructor is finished, it would save unnecessary constructor writing  
in some cases. It would be especially useful when Derived is using the  
same constructor interface as Base (case 2) except the constructors should  
do something additional also (subtype of case 3). For example:

class Base {
     this() {
         m_val = -1;
         }
     this(int val) {
         m_val = val;
         }

     void f() {
         m_val = 100;
         }

     int m_val;
}

class Derived : Base {
     this_polish() {  //is called after a constructor
         f();
         }
}

void func() {
     Derived obj = new Derived(1);  //'obj.m_val' == 100 (first 1, then 100)
}


This would reduce redundant code, which is a possible source for typos and  
errors. It would also be easier to maintain: if parameter lists of Base's  
constructors are modified, no changes will be required for Derived.