www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Why is the constructor of B called?

reply tcak <1ltkrs+3wyh1ow7kzn1k sharklasers.com> writes:
[code]
import std.stdio;

class B {
	this() {
		writeln("B.constructor");
		foo();
	}

	void foo() {
		writeln("B.foo");
	}
}

class D : B {
	this() {
		writeln("D.constructor");
	}

	override void foo() {
		writeln("D.foo overrides B.foo");
	}
}

void main() {
	auto b = new D();
}
[/code]

Result:

B.constructor
D.foo overrides B.foo
D.constructor

----

There is no use of "super()" in the constructor of D, yet B's 
constructor is called when D is created. Why is that so?

I changed the constructor of D as follows:

[code]
	this() {
		super();
		writeln("D.constructor");
	}
[/code]

Results haven't changed at all. "super()" doesn't make any 
difference. What's going on?

I wouldn't expect B's constructor to be called at all unless 
"super" is used there.
Sep 23 2015
parent reply Adam D. Ruppe <destructionator gmail.com> writes:
On Wednesday, 23 September 2015 at 21:08:37 UTC, tcak wrote:
 I wouldn't expect B's constructor to be called at all unless 
 "super" is used there.
"If no call to constructors via this or super appear in a constructor, and the base class has a constructor, a call to super() is inserted at the beginning of the constructor. " from http://dlang.org/class.html#constructors the idea is to make sure the base class construction work is done too.
Sep 23 2015
parent reply tcak <1ltkrs+3wyh1ow7kzn1k sharklasers.com> writes:
On Wednesday, 23 September 2015 at 21:14:17 UTC, Adam D. Ruppe 
wrote:
 On Wednesday, 23 September 2015 at 21:08:37 UTC, tcak wrote:
 I wouldn't expect B's constructor to be called at all unless 
 "super" is used there.
"If no call to constructors via this or super appear in a constructor, and the base class has a constructor, a call to super() is inserted at the beginning of the constructor. " from http://dlang.org/class.html#constructors the idea is to make sure the base class construction work is done too.
Is there any way to prevent this behaviour? Quickly checked whether Java acts in the same way. Answer is yes.
Sep 23 2015
next sibling parent reply =?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
On 09/23/2015 02:25 PM, tcak wrote:
 On Wednesday, 23 September 2015 at 21:14:17 UTC, Adam D. Ruppe wrote:
 On Wednesday, 23 September 2015 at 21:08:37 UTC, tcak wrote:
 I wouldn't expect B's constructor to be called at all unless "super"
 is used there.
"If no call to constructors via this or super appear in a constructor, and the base class has a constructor, a call to super() is inserted at the beginning of the constructor. " from http://dlang.org/class.html#constructors the idea is to make sure the base class construction work is done too.
Is there any way to prevent this behaviour?
No and I don't think it will ever be implemented. The derived class is supposed to be used as the super class, which involves proper construction of the super parts.
 Quickly checked whether Java acts in the same way. Answer is yes.
Same with C++. As discussed in the other thread, at least D allows changing the order in which the super constructor is executed. Ali
Sep 23 2015
parent "H. S. Teoh via Digitalmars-d-learn" <digitalmars-d-learn puremagic.com> writes:
On Wed, Sep 23, 2015 at 03:25:04PM -0700, Ali ăehreli via Digitalmars-d-learn
wrote:
 On 09/23/2015 02:25 PM, tcak wrote:
On Wednesday, 23 September 2015 at 21:14:17 UTC, Adam D. Ruppe wrote:
On Wednesday, 23 September 2015 at 21:08:37 UTC, tcak wrote:
I wouldn't expect B's constructor to be called at all unless
"super" is used there.
"If no call to constructors via this or super appear in a constructor, and the base class has a constructor, a call to super() is inserted at the beginning of the constructor. " from http://dlang.org/class.html#constructors the idea is to make sure the base class construction work is done too.
Is there any way to prevent this behaviour?
No and I don't think it will ever be implemented. The derived class is supposed to be used as the super class, which involves proper construction of the super parts.
[...] I can't think of any valid use case for not running the base class ctor. Are you sure you aren't violating the Liskov Substitution Principle in some way? It may be that what you need is a has-a relationship rather than an is-a relationship in your class. T -- Once the bikeshed is up for painting, the rainbow won't suffice. -- Andrei Alexandrescu
Sep 23 2015
prev sibling parent reply Nicholas Wilson <iamthewilsonator hotmail.com> writes:
On Wednesday, 23 September 2015 at 21:25:15 UTC, tcak wrote:
 On Wednesday, 23 September 2015 at 21:14:17 UTC, Adam D. Ruppe 
 wrote:
 On Wednesday, 23 September 2015 at 21:08:37 UTC, tcak wrote:
 I wouldn't expect B's constructor to be called at all unless 
 "super" is used there.
"If no call to constructors via this or super appear in a constructor, and the base class has a constructor, a call to super() is inserted at the beginning of the constructor. " from http://dlang.org/class.html#constructors the idea is to make sure the base class construction work is done too.
Is there any way to prevent this behaviour? Quickly checked whether Java acts in the same way. Answer is yes.
You might be able to swap out the vtbl entry for a stub call it and trick the compiler and swap it back, but...
Sep 23 2015
parent reply Marc =?UTF-8?B?U2Now7x0eg==?= <schuetzm gmx.net> writes:
On Thursday, 24 September 2015 at 01:01:09 UTC, Nicholas Wilson 
wrote:
 On Wednesday, 23 September 2015 at 21:25:15 UTC, tcak wrote:
 On Wednesday, 23 September 2015 at 21:14:17 UTC, Adam D. Ruppe 
 wrote:
 On Wednesday, 23 September 2015 at 21:08:37 UTC, tcak wrote:
 I wouldn't expect B's constructor to be called at all unless 
 "super" is used there.
"If no call to constructors via this or super appear in a constructor, and the base class has a constructor, a call to super() is inserted at the beginning of the constructor. " from http://dlang.org/class.html#constructors the idea is to make sure the base class construction work is done too.
Is there any way to prevent this behaviour? Quickly checked whether Java acts in the same way. Answer is yes.
You might be able to swap out the vtbl entry for a stub call it and trick the compiler and swap it back, but...
Urgh... If you can modify the base class, and you really need it, you can check the dynamic type: class Base { this() { if(!cast(Base) this) return; // do the initialization } }
Sep 24 2015
next sibling parent Nicholas Wilson <iamthewilsonator hotmail.com> writes:
On Thursday, 24 September 2015 at 11:26:12 UTC, Marc Sch├╝tz wrote:
 On Thursday, 24 September 2015 at 01:01:09 UTC, Nicholas Wilson 
 wrote:
 On Wednesday, 23 September 2015 at 21:25:15 UTC, tcak wrote:
 On Wednesday, 23 September 2015 at 21:14:17 UTC, Adam D. 
 Ruppe wrote:
 [...]
Is there any way to prevent this behaviour? Quickly checked whether Java acts in the same way. Answer is yes.
You might be able to swap out the vtbl entry for a stub call it and trick the compiler and swap it back, but...
Urgh... If you can modify the base class, and you really need it, you can check the dynamic type: class Base { this() { if(!cast(Base) this) return; // do the initialization } }
doesn't upcasting always work? iirc only down casting can return null.
Sep 24 2015
prev sibling parent Artur Skawina via Digitalmars-d-learn <digitalmars-d-learn puremagic.com> writes:
On 09/24/15 13:26, Marc Sch├╝tz via Digitalmars-d-learn wrote:
 On Thursday, 24 September 2015 at 01:01:09 UTC, Nicholas Wilson wrote:
 On Wednesday, 23 September 2015 at 21:25:15 UTC, tcak wrote:
 On Wednesday, 23 September 2015 at 21:14:17 UTC, Adam D. Ruppe wrote:
 On Wednesday, 23 September 2015 at 21:08:37 UTC, tcak wrote:
 I wouldn't expect B's constructor to be called at all unless "super" is used
there.
"If no call to constructors via this or super appear in a constructor, and the base class has a constructor, a call to super() is inserted at the beginning of the constructor. " from http://dlang.org/class.html#constructors the idea is to make sure the base class construction work is done too.
Is there any way to prevent this behaviour? Quickly checked whether Java acts in the same way. Answer is yes.
You might be able to swap out the vtbl entry for a stub call it and trick the compiler and swap it back, but...
Urgh... If you can modify the base class, and you really need it, you can check the dynamic type: class Base { this() { if(!cast(Base) this) return; // do the initialization } }
If you're going to do this then you can just use overloading. That will both avoid the runtime check and require the hack to be explicitly enabled in the derived class. IOW: class B { this() { writeln("B.constructor"); foo(); } struct SkipBCtor {} this(SkipBCtor) {} void foo() { writeln("B.foo"); } } class D : B { this() { super(SkipBCtor()); writeln("D.constructor"); } override void foo() { writeln("D.foo overrides B.foo"); } } artur
Sep 24 2015