• Uldis (36/36) Mar 12 2016 While writing a structs function that I wanted to minimize
• JR (4/13) Mar 12 2016 I'll let others more knowledgeable explain why, but tack an
• Jack Applegame (3/5) Mar 12 2016 https://dlang.org/library/object/assume_safe_append.html
• Adam D. Ruppe (5/6) Mar 12 2016 Details here: http://dlang.org/d-array-article.html

Uldis <uldis.kalninsh gmail.com> writes:

While writing a structs function that I wanted to minimize 
allocations and use an internal preallocated buffer, but I 
noticed that arrays are losing their capacity when its length is 
changed.

For example:

void main() {

         int[] a;
         a.reserve = 1024;

         void dump(in ref int[] b,size_t line = __LINE__) {
                 import std.stdio;
                 writeln(line, ": Buffer length = ", b.length, " 
capacity= ", b.capacity);
         }
         dump(a); // line 10
         a.length = 0;
         dump(a);
         a ~= [1,2,3];
         dump(a);
         a.length = 0;
         dump(a);
         a ~= [4,5,6];
         dump(a);
}

gives output:

10: Buffer length = 0 capacity= 2043
12: Buffer length = 0 capacity= 2043
14: Buffer length = 3 capacity= 2043
16: Buffer length = 0 capacity= 0
18: Buffer length = 3 capacity= 3

but I expected:

10: Buffer length = 0 capacity= 2043
12: Buffer length = 0 capacity= 2043
14: Buffer length = 3 capacity= 2043
16: Buffer length = 0 capacity= 2043
18: Buffer length = 3 capacity= 2043


Why is this happening, how to avoid it?

JR <sunspyre gmail.com> writes:

On Saturday, 12 March 2016 at 09:56:48 UTC, Uldis wrote:
         dump(a); // line 10
         a.length = 0;
         dump(a);
         a ~= [1,2,3];
         dump(a);
         a.length = 0;
         dump(a);
         a ~= [4,5,6];
         dump(a);

I'll let others more knowledgeable explain why, but tack an 
a.assumeSafeAppend() after the length change and you'll get your 
desired behaviour.

Jack Applegame <japplegame gmail.com> writes:

 Why is this happening...?

For safety reasons. Your array can be shared between parts of 
application.
 ...how to avoid it?

https://dlang.org/library/object/assume_safe_append.html

Adam D. Ruppe <destructionator gmail.com> writes:

On Saturday, 12 March 2016 at 09:56:48 UTC, Uldis wrote:
 Why is this happening, how to avoid it?

Details here: http://dlang.org/d-array-article.html

it is so one slice can never stomp over the contents of another 
slice when you append to it.

array.assumeSafeAppend() can override it.