• Kristian (68/68) Aug 21 2006 Let there be classes Base and Derived. Base is the base class of Derived...
• Kristian (1/1) Aug 21 2006 Sorry, wrong news group!

Kristian <kjkilpi gmail.com> writes:

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 t=
he  =

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 =3D new Derived(1);  //calls 'Base.this(int)' (now a co=
mpile  =

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 aft=
er  =

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 shou=
ld  =

do something additional also (subtype of case 3). For example:

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

     void f() {
         m_val =3D 100;
         }

     int m_val;
}

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

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


This would reduce redundant code, which is a possible source for typos a=
nd  =

errors. It would also be easier to maintain: if parameter lists of Base'=
s  =

constructors are modified, no changes will be required for Derived.

Kristian <kjkilpi gmail.com> writes:

Sorry, wrong news group!