www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Passing parameter when creating object array

reply Dan <twinbee41 skytopia.com> writes:
I've just found out from elsewhere that it's not possible in C++ to create an
array of objects whilst simultaneously passing a parameter to the constructor
of each of those objects. Something like this returns an error:

Myclass x (10)[50]

I don't want to have to do:

Myclass x[5] = {10,10,10,10,10,10.................}  // ...and so on

Does D support the more intuitive Myclass x (10)[50] mechanism?
Aug 06 2007
next sibling parent "Jarrett Billingsley" <kb3ctd2 yahoo.com> writes:
"Dan" <twinbee41 skytopia.com> wrote in message 
news:f98h52$7bj$1 digitalmars.com...

 I've just found out from elsewhere that it's not possible in C++ to create 
 an array of objects whilst simultaneously passing a parameter to the 
 constructor of each of those objects. Something like this returns an 
 error:

 Myclass x (10)[50]

 I don't want to have to do:

 Myclass x[5] = {10,10,10,10,10,10.................}  // ...and so on

 Does D support the more intuitive Myclass x (10)[50] mechanism?


D doesn't support instantiating an array of instances of classes in one 
statement in any way, so.. no.
Aug 06 2007
prev sibling parent reply James Dennett <jdennett acm.org> writes:
Dan wrote:

 I've just found out from elsewhere that it's not possible in C++ to create an
array of objects whilst simultaneously passing a parameter to the constructor
of each of those objects. Something like this returns an error:
 
 Myclass x (10)[50]
 
 I don't want to have to do:
 
 Myclass x[5] = {10,10,10,10,10,10.................}  // ...and so on
 
 Does D support the more intuitive Myclass x (10)[50] mechanism?


C++ has a library type for arrays, where you can write

std::vector<MyClass> x(50, MyClass(10));

D tends to prefer pushing this kind of thing out of the library
and into the language, but maybe somebody can point out the D
library solution for this.

-- James
Aug 06 2007
parent reply Chris Nicholson-Sauls <ibisbasenji gmail.com> writes:
James Dennett wrote:

 Dan wrote:

 I've just found out from elsewhere that it's not possible in C++ to create an
array of objects whilst simultaneously passing a parameter to the constructor
of each of those objects. Something like this returns an error:

 Myclass x (10)[50]

 I don't want to have to do:

 Myclass x[5] = {10,10,10,10,10,10.................}  // ...and so on

 Does D support the more intuitive Myclass x (10)[50] mechanism?


 
 C++ has a library type for arrays, where you can write
 
 std::vector<MyClass> x(50, MyClass(10));
 
 D tends to prefer pushing this kind of thing out of the library
 and into the language, but maybe somebody can point out the D
 library solution for this.
 
 -- James


Its straightforward:

T[] populateArray (T) (int len, lazy T ctor) {
     T[] result = new T[len];

     foreach (inout elem; result) {
         elem = ctor();
     }
     return result;
}


Usage is like so:

auto array = populateArray(50, new MyClass(10));



This also works fine with structures, and technically any other type. 
Although its inefficient for basic scalars, for that use a slice-assignment:

int[]   arr1 = new int[50]; arr1[] = 10;
int[50] arr2;               arr2[] = 10;


-- Chris Nicholson-Sauls
Aug 07 2007
parent reply Kirk McDonald <kirklin.mcdonald gmail.com> writes:
Chris Nicholson-Sauls wrote:

 James Dennett wrote:

 Dan wrote:

 I've just found out from elsewhere that it's not possible in C++ to 
 create an array of objects whilst simultaneously passing a parameter 
 to the constructor of each of those objects. Something like this 
 returns an error:

 Myclass x (10)[50]

 I don't want to have to do:

 Myclass x[5] = {10,10,10,10,10,10.................}  // ...and so on

 Does D support the more intuitive Myclass x (10)[50] mechanism?


 C++ has a library type for arrays, where you can write

 std::vector<MyClass> x(50, MyClass(10));

 D tends to prefer pushing this kind of thing out of the library
 and into the language, but maybe somebody can point out the D
 library solution for this.

 -- James


 
 Its straightforward:
 
 T[] populateArray (T) (int len, lazy T ctor) {
     T[] result = new T[len];
 
     foreach (inout elem; result) {
         elem = ctor();
     }
     return result;
 }
 
 
 Usage is like so:
 
 auto array = populateArray(50, new MyClass(10));
 
 
 
 This also works fine with structures, and technically any other type. 
 Although its inefficient for basic scalars, for that use a 
 slice-assignment:
 
 int[]   arr1 = new int[50]; arr1[] = 10;
 int[50] arr2;               arr2[] = 10;
 
 
 -- Chris Nicholson-Sauls


Using new on a dynamic array type already allows you to pass something 
looking like a constructor call:

auto a = new int[](50); // An array of 50 elements

It might be appropriate to add a second, optional parameter to this 
constructor, with the array's default initializer:

auto b = new int[](50, 5); // An array of 50 5s

This implies that, for arrays of class references, saying this

auto c = new Foo[](10, new Foo);

would result in an array of 10 references to the same instance of Foo. I 
believe that any other behavior would be surprising.

Therefore, some notation must be provided for allocating an array and 
not initializing its contents, which would allow something like your 
lazy initializer above to operate without initializing the array's 
contents first. A number of ideas occur to me; the simplest is perhaps 
an optional argument to 'new' itself:

auto d = new(false) Foo[](10); // Allocate array, don't initialize it.

All of this being said, I am not sure how serious of an issue this 
really is.

-- 
Kirk McDonald
http://kirkmcdonald.blogspot.com
Pyd: Connecting D and Python
http://pyd.dsource.org
Aug 07 2007
next sibling parent reply Deewiant <deewiant.doesnotlike.spam gmail.com> writes:
Kirk McDonald wrote:

 Using new on a dynamic array type already allows you to pass something
 looking like a constructor call:
 
 auto a = new int[](50); // An array of 50 elements
 
 It might be appropriate to add a second, optional parameter to this
 constructor, with the array's default initializer:
 
 auto b = new int[](50, 5); // An array of 50 5s


This syntax is already taken, for allocating nested arrays:
http://www.digitalmars.com/d/expression.html#NewExpression

-- 
Remove ".doesnotlike.spam" from the mail address.
Aug 07 2007
parent Kirk McDonald <kirklin.mcdonald gmail.com> writes:
Deewiant wrote:

 Kirk McDonald wrote:
 

Using new on a dynamic array type already allows you to pass something
looking like a constructor call:

auto a = new int[](50); // An array of 50 elements

It might be appropriate to add a second, optional parameter to this
constructor, with the array's default initializer:

auto b = new int[](50, 5); // An array of 50 5s


 
 
 This syntax is already taken, for allocating nested arrays:
 http://www.digitalmars.com/d/expression.html#NewExpression
 


It could still work. Nested (or un-nested) dynamic array types would 
have two constructors: The existing ones, for defining the size of the 
array, and one with one additional argument, defining the default 
initializer of the innermost array's elements.

Therefore:

new char[][](10) // allocate an array of 10 strings
new char[][](10, 20) // allocate 10 strings of 20 \0 characters
new char[][](10, 20, 'a') // allocate 10 strings of 20 'a's.

But now I'm having trouble understanding another part of that page:

"If there is a new ( ArgumentList ), then those arguments are passed to 
the class or struct specific allocator function after the size argument."

For classes, saying 'new C[](20)' creates an array of 20 class 
/references/, set to null, and the class's allocator is never called.

For structs, it is not the structs themselves being new'ed. A struct's 
allocator overload is used when you say 'new S', which returns an S*. 
Saying 'new S[](20)' will create an array whose size in bytes is 
S.sizeof * 20. The struct's allocator has nothing to do with it.

Creating an array of type S*[] has basically the same issue as an array 
of class references: The pointers are initialized to null, and the 
struct's allocator is never called.

Therefore, this line in the spec appears to be useless, and my 
new(false) suggestion could still work.

-- 
Kirk McDonald
http://kirkmcdonald.blogspot.com
Pyd: Connecting D and Python
http://pyd.dsource.org
Aug 07 2007
prev sibling parent reply Chris Nicholson-Sauls <ibisbasenji gmail.com> writes:
Kirk McDonald wrote:

 Chris Nicholson-Sauls wrote:

 James Dennett wrote:

 Dan wrote:

 I've just found out from elsewhere that it's not possible in C++ to 
 create an array of objects whilst simultaneously passing a parameter 
 to the constructor of each of those objects. Something like this 
 returns an error:

 Myclass x (10)[50]

 I don't want to have to do:

 Myclass x[5] = {10,10,10,10,10,10.................}  // ...and so on

 Does D support the more intuitive Myclass x (10)[50] mechanism?


 C++ has a library type for arrays, where you can write

 std::vector<MyClass> x(50, MyClass(10));

 D tends to prefer pushing this kind of thing out of the library
 and into the language, but maybe somebody can point out the D
 library solution for this.

 -- James


 Its straightforward:

 T[] populateArray (T) (int len, lazy T ctor) {
     T[] result = new T[len];

     foreach (inout elem; result) {
         elem = ctor();
     }
     return result;
 }


 Usage is like so:

 auto array = populateArray(50, new MyClass(10));



 This also works fine with structures, and technically any other type. 
 Although its inefficient for basic scalars, for that use a 
 slice-assignment:

 int[]   arr1 = new int[50]; arr1[] = 10;
 int[50] arr2;               arr2[] = 10;


 -- Chris Nicholson-Sauls


 
 Using new on a dynamic array type already allows you to pass something 
 looking like a constructor call:
 
 auto a = new int[](50); // An array of 50 elements
 
 It might be appropriate to add a second, optional parameter to this 
 constructor, with the array's default initializer:
 
 auto b = new int[](50, 5); // An array of 50 5s
 
 This implies that, for arrays of class references, saying this
 
 auto c = new Foo[](10, new Foo);
 
 would result in an array of 10 references to the same instance of Foo. I 
 believe that any other behavior would be surprising.
 
 Therefore, some notation must be provided for allocating an array and 
 not initializing its contents, which would allow something like your 
 lazy initializer above to operate without initializing the array's 
 contents first. A number of ideas occur to me; the simplest is perhaps 
 an optional argument to 'new' itself:
 
 auto d = new(false) Foo[](10); // Allocate array, don't initialize it.
 
 All of this being said, I am not sure how serious of an issue this 
 really is.
 


Hmm.  That could be rather dangerous, actually.  So here's another 
thought.  Let's get 'new int[5][10][15]' working, then redefine the 
trailing parentheses to specify an initializor, and then furthermore 
make that initializor lazy anytime it is more complex than a literal or 
symbol, possibly including 'symbol.symbol' as field reads.

auto array = new MyClass[50](new MyClass(10));

You know, now that I actually see it... I'm not so fond of it.

But honestly, I don't think the cost is worth worrying too much about. 
I ran a quick test timing my function above against a simple foreach 
over an pre-allocated array.  The 'populate' function averaged only 10 
microseconds slower.  I, for one, can handle 10 millionths of almost 
anything.  :)

-- Chris Nicholson-Sauls
Aug 07 2007
parent reply Chris Nicholson-Sauls <ibisbasenji gmail.com> writes:
Chris Nicholson-Sauls wrote:

 Kirk McDonald wrote:

 Chris Nicholson-Sauls wrote:

 James Dennett wrote:

 Dan wrote:

 I've just found out from elsewhere that it's not possible in C++ to 
 create an array of objects whilst simultaneously passing a 
 parameter to the constructor of each of those objects. Something 
 like this returns an error:

 Myclass x (10)[50]

 I don't want to have to do:

 Myclass x[5] = {10,10,10,10,10,10.................}  // ...and so on

 Does D support the more intuitive Myclass x (10)[50] mechanism?


 C++ has a library type for arrays, where you can write

 std::vector<MyClass> x(50, MyClass(10));

 D tends to prefer pushing this kind of thing out of the library
 and into the language, but maybe somebody can point out the D
 library solution for this.

 -- James


 Its straightforward:

 T[] populateArray (T) (int len, lazy T ctor) {
     T[] result = new T[len];

     foreach (inout elem; result) {
         elem = ctor();
     }
     return result;
 }


 Usage is like so:

 auto array = populateArray(50, new MyClass(10));



 This also works fine with structures, and technically any other type. 
 Although its inefficient for basic scalars, for that use a 
 slice-assignment:

 int[]   arr1 = new int[50]; arr1[] = 10;
 int[50] arr2;               arr2[] = 10;


 -- Chris Nicholson-Sauls


 Using new on a dynamic array type already allows you to pass something 
 looking like a constructor call:

 auto a = new int[](50); // An array of 50 elements

 It might be appropriate to add a second, optional parameter to this 
 constructor, with the array's default initializer:

 auto b = new int[](50, 5); // An array of 50 5s

 This implies that, for arrays of class references, saying this

 auto c = new Foo[](10, new Foo);

 would result in an array of 10 references to the same instance of Foo. 
 I believe that any other behavior would be surprising.

 Therefore, some notation must be provided for allocating an array and 
 not initializing its contents, which would allow something like your 
 lazy initializer above to operate without initializing the array's 
 contents first. A number of ideas occur to me; the simplest is perhaps 
 an optional argument to 'new' itself:

 auto d = new(false) Foo[](10); // Allocate array, don't initialize it.

 All of this being said, I am not sure how serious of an issue this 
 really is.


 
 Hmm.  That could be rather dangerous, actually.  So here's another 
 thought.  Let's get 'new int[5][10][15]' working, then redefine the 
 trailing parentheses to specify an initializor, and then furthermore 
 make that initializor lazy anytime it is more complex than a literal or 
 symbol, possibly including 'symbol.symbol' as field reads.
 
 auto array = new MyClass[50](new MyClass(10));
 
 You know, now that I actually see it... I'm not so fond of it.
 
 But honestly, I don't think the cost is worth worrying too much about. I 
 ran a quick test timing my function above against a simple foreach over 
 an pre-allocated array.  The 'populate' function averaged only 10 
 microseconds slower.  I, for one, can handle 10 millionths of almost 
 anything.  :)
 
 -- Chris Nicholson-Sauls


Oh yes, I should probably also mention that my test program was creating 
arrays of 1000 objects -- not just 50.  :)  So for use cases such as in 
the OP, the difference is utterly insignificant.

-- Chris Nicholson-Sauls
Aug 07 2007
parent Kirk McDonald <kirklin.mcdonald gmail.com> writes:
Chris Nicholson-Sauls wrote:

 But honestly, I don't think the cost is worth worrying too much about. 
 I ran a quick test timing my function above against a simple foreach 
 over an pre-allocated array.  The 'populate' function averaged only 10 
 microseconds slower.  I, for one, can handle 10 millionths of almost 
 anything.  :)

 -- Chris Nicholson-Sauls


 
 
 Oh yes, I should probably also mention that my test program was creating 
 arrays of 1000 objects -- not just 50.  :)  So for use cases such as in 
 the OP, the difference is utterly insignificant.
 
 -- Chris Nicholson-Sauls


Hence why I said I wasn't sure how serious of an issue this is. :-)

-- 
Kirk McDonald
http://kirkmcdonald.blogspot.com
Pyd: Connecting D and Python
http://pyd.dsource.org
Aug 07 2007