## digitalmars.D.learn - Basic dynamic array question. Use of new versus no new.

"WhatMeWorry" <kc_heaser yahoo.com> writes:
In Mr. Cehreli's book it says

Additionally, the length of dynamic arrays can be changed by
assigning a value to this property:

int[] array; // initially empty
array.length = 5; // now has 5 elements

while in Mr. Alexandrescu's book, it says

To create a dynamic array, use a new expression (§ 2.3.6.1 on
page 51) as follows:

int[] array = new int[20]; // Create an array of 20 integers

Could someone please compare and contrast the two syntaxes. I
presume the "new" command places the 2nd array in heap memory.
Jun 10 2014
"Matt" <webwraith fastmail.fm> writes:
On Wednesday, 11 June 2014 at 02:30:01 UTC, WhatMeWorry wrote:
In Mr. Cehreli's book it says

Additionally, the length of dynamic arrays can be changed by
assigning a value to this property:

int[] array; // initially empty
array.length = 5; // now has 5 elements

while in Mr. Alexandrescu's book, it says

To create a dynamic array, use a new expression (§ 2.3.6.1 on
page 51) as follows:

int[] array = new int[20]; // Create an array of 20 integers

Could someone please compare and contrast the two syntaxes. I
presume the "new" command places the 2nd array in heap memory.
I would have read the second as creating a static array of 20 ints in heap memory, then assigning a dynamic array to point to it. The first one definitely does what you'd expect. Wasn't Andres book based on D1.0? Or has he done another since then?
Jun 10 2014
=?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 06/10/2014 08:06 PM, Matt wrote:

On Wednesday, 11 June 2014 at 02:30:01 UTC, WhatMeWorry wrote:
int[] array; // initially empty
array.length = 5; // now has 5 elements

while in Mr. Alexandrescu's book, it says

To create a dynamic array, use a new expression (§ 2.3.6.1 on page 51)
as follows:

int[] array = new int[20]; // Create an array of 20 integers
I would have read the second as creating a static array of 20 ints in
heap memory, then assigning a dynamic array to point to it.
Correct but it is not different from the first one, other than doing it in one step.
Wasn't Andres book based on D1.0? Or has he done another since then?
No. TDPL is a D2 book, which has naturally been behind the newer developments since the book has been published. Here is the errata: http://erdani.com/tdpl/errata/ Ali
Jun 10 2014
"monarch_dodra" <monarchdodra gmail.com> writes:
On Wednesday, 11 June 2014 at 05:46:07 UTC, Ali Çehreli wrote:
On 06/10/2014 08:06 PM, Matt wrote:

On Wednesday, 11 June 2014 at 02:30:01 UTC, WhatMeWorry wrote:
int[] array; // initially empty
array.length = 5; // now has 5 elements

while in Mr. Alexandrescu's book, it says

To create a dynamic array, use a new expression (§ 2.3.6.1
on page 51)
as follows:

int[] array = new int[20]; // Create an array of 20 integers
I would have read the second as creating a static array of 20
ints in
heap memory, then assigning a dynamic array to point to it.
Correct but it is not different from the first one, other than doing it in one step.
Wait, what? That's not correct. "new int[20]" is simply "one of two" syntaxes to allocate an array of 20 ints, the other being "new int[](20)". It does NOT allocate a static array, and then slice it. Proof is that there is APPENDABLE data present, which should not happen if you had actually simply allocated a single element of type int[20] (APPENDABLE data is only present for array-style allocation). AFAIK, there is no "natural" way to allocate either a static array or a slice itslef, using new syntax. It can be done via the "wrapper struct" hack though: //---- //Used to allocate a slice "int[]". //Or a static array "int[20]" on the heap. struct NewWrapper(T) { T data; } void main() { int[] arr1 = new int[20]; int[] arr2 = (new NewWrapper!(int[20])).data[]; writeln(arr1.length); //20, as expected writeln(arr1.capacity); //31 on my machine writeln(arr2.length); //20 writeln(arr2.capacity); //0 } //---- Too bad the ambiguous syntax has us resolve to these tricks. It also prevents value constructing an array of elements. A syntax where the array sizes came *before* the type could have solved these issue: int size = 20; new size int[5]([1, 2, 3, 4, 5]); Allocate "20" (runtime) elements of type "int[5]", each initialized to the value ([1, 2, 3, 4, 5]). But, well, that ship has set sail long ago :(
Jun 11 2014
"Kapps" <opantm2+spam gmail.com> writes:
On Wednesday, 11 June 2014 at 02:30:01 UTC, WhatMeWorry wrote:
In Mr. Cehreli's book it says

Additionally, the length of dynamic arrays can be changed by
assigning a value to this property:

int[] array; // initially empty
array.length = 5; // now has 5 elements

while in Mr. Alexandrescu's book, it says

To create a dynamic array, use a new expression (§ 2.3.6.1 on
page 51) as follows:

int[] array = new int[20]; // Create an array of 20 integers

Could someone please compare and contrast the two syntaxes. I
presume the "new" command places the 2nd array in heap memory.
They both do the same, create an array of n integers on the heap and set the length to n. You can also use .capacity instead of .length to allocate n but not adjust length.
Jun 10 2014
"Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Tue, 10 Jun 2014 23:28:16 -0400, Kapps <opantm2+spam gmail.com> wrote=
:

On Wednesday, 11 June 2014 at 02:30:01 UTC, WhatMeWorry wrote:
In Mr. Cehreli's book it says

Additionally, the length of dynamic arrays can be changed by assignin=
g =
a value to this property:

int[] array; // initially empty
array.length =3D 5; // now has 5 elements

while in Mr. Alexandrescu's book, it says

To create a dynamic array, use a new expression (=C2=A7 2.3.6.1 on pa=
ge 51) =
as follows:

int[] array =3D new int[20]; // Create an array of 20 integers

Could someone please compare and contrast the two syntaxes. I presume=
=
the "new" command places the 2nd array in heap memory.
They both do the same, create an array of n integers on the heap and s=
et =
the length to n. You can also use .capacity instead of .length to  =
allocate n but not adjust length.
This is slightly incorrect. Here is the difference as I see it: 1. Setting length goes through the extra steps of checking the current = length, looking up the existing block (obviously with initial value of = null, there isn't one), and allocating if necessary. A lot more code is = = executed. 2. The 'new' call will ALWAYS allocate a new block, even if array = previously had data in it. 3. The block size allocated is not always n, it could be more. 4. You meant 'reserve', not 'capacity'. capacity checks how many element= s = the block can support. Which way is easier/better? If you know you are starting with a blank = array, then new is the way to go. This avoids any unnecessary extra chec= ks = for existing data. The second way is required if you may already have some data in the arra= y = (i.e. prior to setting the length, arr.length !=3D 0). Also, I would recommend to use: auto array =3D new int[20] To avoid repeating the type. -Steve
Jun 11 2014
Jonathan M Davis via Digitalmars-d-learn writes:
On Wed, 11 Jun 2014 02:30:00 +0000
WhatMeWorry via Digitalmars-d-learn <digitalmars-d-learn puremagic.com>
wrote:

In Mr. Cehreli's book it says

Additionally, the length of dynamic arrays can be changed by
assigning a value to this property:

int[] array; // initially empty
array.length = 5; // now has 5 elements

while in Mr. Alexandrescu's book, it says

To create a dynamic array, use a new expression (§ 2.3.6.1 on
page 51) as follows:

int[] array = new int[20]; // Create an array of 20 integers

Could someone please compare and contrast the two syntaxes. I
presume the "new" command places the 2nd array in heap memory.
They do essentially the same thing but, the first one does it in two steps instead of one. To better understand arrays in D, I'd advise reading this article: http://dlang.org/d-array-article.html - Jonathan M Davis
Jun 11 2014