www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - initializer list like in C++?

reply Hoenir <mrmocool gmx.de> writes:
Is there anything like the initializer list (C++) in D?

class Test {
	int x;
	Test(int y):x(y){};
}
Jul 24 2007
next sibling parent Chris Nicholson-Sauls <ibisbasenji gmail.com> writes:
Hoenir wrote:
 Is there anything like the initializer list (C++) in D?
 
 class Test {
     int x;
     Test(int y):x(y){};
 }

class Test { int x ; this (int y) { x = y; } } ;) Or in short: no. Not that I've ever missed it at all. -- Chris Nicholson-Sauls
Jul 24 2007
prev sibling next sibling parent reply "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Hoenir" <mrmocool gmx.de> wrote in message 
news:f84rnt$1db0$1 digitalmars.com...
 Is there anything like the initializer list (C++) in D?

 class Test {
 int x;
 Test(int y):x(y){};
 }

No. See http://www.digitalmars.com/d/archives/digitalmars/D/initializat on_lists_55262.html for an explanation on why D doesn't have them.
Jul 24 2007
parent reply James Dennett <jdennett acm.org> writes:
Jarrett Billingsley wrote:
 "Hoenir" <mrmocool gmx.de> wrote in message 
 news:f84rnt$1db0$1 digitalmars.com...
 Is there anything like the initializer list (C++) in D?

 class Test {
 int x;
 Test(int y):x(y){};
 }

No. See http://www.digitalmars.com/d/archives/digitalmars/D/initializat on_lists_55262.html for an explanation on why D doesn't have them.

I looked at that thread, but found only references to performance, which miss the main reason why these are present/useful in C++: semantics. There are various kinds of things in C++ that can be initialized but cannot be modified, because of references, const-ness, and classes with immutable value semantics. The occasional/slight performance benefit is definitely secondary to the ability to express meaning directly in the code. As D gains the ability to model such immutable members, it might benefit from finding (its own) solution to the same issue. -- James
Jul 24 2007
parent reply BCS <ao pathlink.com> writes:
Reply to James,

 Jarrett Billingsley wrote:
 
 "Hoenir" <mrmocool gmx.de> wrote in message
 news:f84rnt$1db0$1 digitalmars.com...
 
 Is there anything like the initializer list (C++) in D?
 
 class Test {
 int x;
 Test(int y):x(y){};
 }

http://www.digitalmars.com/d/archives/digitalmars/D/initialization_li sts_55262.html for an explanation on why D doesn't have them.

which miss the main reason why these are present/useful in C++: semantics. There are various kinds of things in C++ that can be initialized but cannot be modified, because of references, const-ness, and classes with immutable value semantics. The occasional/slight performance benefit is definitely secondary to the ability to express meaning directly in the code. As D gains the ability to model such immutable members, it might benefit from finding (its own) solution to the same issue.

IIRC this works const int i; static this(){i=5;} class C { const char c; this(char c_){c=c_;} }
Jul 24 2007
parent reply James Dennett <jdennett acm.org> writes:
BCS wrote:
 Reply to James,
 
 Jarrett Billingsley wrote:

 "Hoenir" <mrmocool gmx.de> wrote in message
 news:f84rnt$1db0$1 digitalmars.com...

 Is there anything like the initializer list (C++) in D?

 class Test {
 int x;
 Test(int y):x(y){};
 }

http://www.digitalmars.com/d/archives/digitalmars/D/initialization_li sts_55262.html for an explanation on why D doesn't have them.

which miss the main reason why these are present/useful in C++: semantics. There are various kinds of things in C++ that can be initialized but cannot be modified, because of references, const-ness, and classes with immutable value semantics. The occasional/slight performance benefit is definitely secondary to the ability to express meaning directly in the code. As D gains the ability to model such immutable members, it might benefit from finding (its own) solution to the same issue.

IIRC this works const int i; static this(){i=5;} class C { const char c; this(char c_){c=c_;} }

Can c be modified more than once during construction? If not, what rules are used to determine when it's been modified? Java came up with "definite assignment" rules for this kind of things, and they're pretty decent -- they guarantee that a final value is assigned a value exactly once, while allowing for some flexibility such as setting it down all branches of an if/else. -- James
Jul 24 2007
parent Chris Nicholson-Sauls <ibisbasenji gmail.com> writes:
James Dennett wrote:
 BCS wrote:
 Reply to James,

 Jarrett Billingsley wrote:

 "Hoenir" <mrmocool gmx.de> wrote in message
 news:f84rnt$1db0$1 digitalmars.com...

 Is there anything like the initializer list (C++) in D?

 class Test {
 int x;
 Test(int y):x(y){};
 }

http://www.digitalmars.com/d/archives/digitalmars/D/initialization_li sts_55262.html for an explanation on why D doesn't have them.

which miss the main reason why these are present/useful in C++: semantics. There are various kinds of things in C++ that can be initialized but cannot be modified, because of references, const-ness, and classes with immutable value semantics. The occasional/slight performance benefit is definitely secondary to the ability to express meaning directly in the code. As D gains the ability to model such immutable members, it might benefit from finding (its own) solution to the same issue.

const int i; static this(){i=5;} class C { const char c; this(char c_){c=c_;} }

Can c be modified more than once during construction? If not, what rules are used to determine when it's been modified? Java came up with "definite assignment" rules for this kind of things, and they're pretty decent -- they guarantee that a final value is assigned a value exactly once, while allowing for some flexibility such as setting it down all branches of an if/else. -- James

As I understand it: === D/1.x === Const fields/variables can be assigned and otherwise modified freely within relevant constructors, being otherwise iron-clad. I believe its a compile-time check only, with available hardware protections at runtime. === D/2.x === Final fields/variables are assign-once, from anywhere, with some check bit being set thereafter to prevent rebinding. Const takes on a meaning relevant to the actual data only, and so means nothing for the discussion at hand. (I may be wrong; for example, it may be that constructors specifically take liberties with 2.x final as they do with 1.x const.) -- Chris Nicholson-Sauls
Jul 24 2007
prev sibling parent reply Daniel919 <Daniel919 web.de> writes:
http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=55262

Best regards,
Daniel
Jul 24 2007
parent Hoenir <mrmocool gmx.de> writes:
Thank you all for your answers :)
Jul 24 2007