On Monday, 8 June 2015 at 06:35:33 UTC, Jonathan M Davis wrote:
On Monday, 8 June 2015 at 06:04:23 UTC, Tofu Ninja wrote:
No its definitely not something that alot of people seem to
care about, but I always found it odd that constructors get
certain special casing like this.
I expect that it originally comes down to the fact that
constructors aren't polymorphic and _can't_ be polymorphic.
When you override a function, you're overriding the one in the
base class and replacing its implementation. You can choose to
call the base class' version of the function, but you don't
have to. You're dynamically replacing a function.
Constructors, on the other hand, do _not_ override. A
constructor must exist in _every_ class in the inheritance
tree, and they all have to be called - and called in the right
order. When you "inherit" a constructor, you're not overriding
the one in the base class. You _still_ have to have
constructors in both the base class and derived class. You're
just telling the compiler to insert a constructor into the
derived class which has exactly the same parameters as one in
the base class and which simply forwards its arguments to the
base class' constructor. There's no polymorphism involved at
all. It's simply syntactic sugar to avoid having to type out
the whole constructor implementation yourself. There's nothing
dynamic about it all. Inherited constructors are truly just
syntactic sugar. So, while they may be useful (as syntactic
sugar often is), they add _zero_ functionality, unlike virtual
functions.
So, yes, constructors _are_ fundamentally different from other
functions. And the inheritance that you get with constructors
is not at all what you get when you override a function.
They're at most superficially similar. And older languages such
as C++98 and Java don't have inherited constructors. They're a
relatively new idea. So, if anything, it would be surprising if
D had them. Constructors are just different beasts from other
functions (the same goes for destructors). And while D has lots
of new ideas in it, it's not like we have all of the cool, new
language ideas out there. Maybe we'll get constructor
inheritance someday, but no one has cared enough to add it thus
far.
- Jonathan M Davis
I suppose I just see it differently. I see no reason why
constructors need to be different from normal virtual methods
other than the small requirement that they need to call their
base if they override. That requirement is not really something
specific to constructors either, plenty of other types of
functions would benefit from that sort of guarantee.
Constructors need not exist in every instance of the tree, if the
class implementor deemed the base constructor to be sufficient
then that should be allowed. Plenty of times people will just
insert empty constructors in sub classes that only forward
arguments to the base. That forwarding constructor is not needed,
just call the base constructor in the same way normal virtual
methods work.
Also constructors certainly can be polymorphic and the
aforementioned base call guarantee does not make it so that they
cant. Deferred construction certainly allows for polymorphic
construction. Aka allocate and set up static
information(including type information) without calling a
constructor so that it can be called at a later time. In the time
between allocation and construction, that instance could be
assigned to reference of the base type and construction could be
polymorphic.
The only issue one would have with this is if a base
constructor's signature was no long sufficient to fully construct
the object, in which case it would make sense to just override
and throw an exception the same way you would restrict any method
signatures usage. That solution though wouldn't really work for D
at this point which is why it would probably make more sense to
make it opt-in at the base class level.
