www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Local fixed sized arrays

reply "Smoke" Adams <SA2432 gmail.com> writes:
I'm in need of a way to create a local array that isn't GC'ed. It 
must be dynamic in the sense of setting the size at compile time 
but it will be used only in scope and only on structs.

function x(int y)
{
    bool[y] arr;

    arr ~= 3;

}

I care about slicing or anything but appending, removal, and 
indexing. I don't even need bounds checking. I don't see a need 
to get locked in to the GC for such simple cases.
Jun 27 2016
next sibling parent reply =?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
On 06/27/2016 02:58 PM, Smoke Adams wrote:

 I'm in need of a way to create a local array that isn't GC'ed. It must
 be dynamic in the sense of setting the size at compile time but it will
 be used only in scope and only on structs.

 function x(int y)
 {
     bool[y] arr;

     arr ~= 3;

 }

 I care about slicing or anything but appending, removal, and indexing. I
 don't even need bounds checking. I don't see a need to get locked in to
 the GC for such simple cases.


One way is to make x() a function template:

import std.stdio;

void x(int y)() {
    bool[y] arr;
    arr[y/2] = true;
    writeln(arr);
}

void main() {
     x!5();
}

Ali
Jun 27 2016
parent reply "Smoke" Adams <SA2432 gmail.com> writes:
On Monday, 27 June 2016 at 22:56:35 UTC, Ali Çehreli wrote:

 On 06/27/2016 02:58 PM, Smoke Adams wrote:

 I'm in need of a way to create a local array that isn't GC'ed. 
 It must
 be dynamic in the sense of setting the size at compile time 
 but it will
 be used only in scope and only on structs.

 function x(int y)
 {
     bool[y] arr;

     arr ~= 3;

 }

 I care about slicing or anything but appending, removal, and 
 indexing. I
 don't even need bounds checking. I don't see a need to get 
 locked in to
 the GC for such simple cases.


 One way is to make x() a function template:

 import std.stdio;

 void x(int y)() {
    bool[y] arr;
    arr[y/2] = true;
    writeln(arr);
 }

 void main() {
     x!5();
 }

 Ali


But the length depends on runtime behavior. Might be 5 or 100. 
This doesn't handle it, does it?

I already make a simple malloc based array that does what I want. 
Looks like a normal array with ~=, [], foreach. Does what I need 
it to do. Only works with BasicTypes of course.
Jun 27 2016
parent =?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
On 06/27/2016 04:02 PM, Smoke Adams wrote:

 On Monday, 27 June 2016 at 22:56:35 UTC, Ali Çehreli wrote:

 On 06/27/2016 02:58 PM, Smoke Adams wrote:

 I'm in need of a way to create a local array that isn't GC'ed. It must
 be dynamic in the sense of setting the size at compile time but it will
 be used only in scope and only on structs.

 function x(int y)
 {
     bool[y] arr;

     arr ~= 3;

 }

 I care about slicing or anything but appending, removal, and 






indexing. I

 don't even need bounds checking. I don't see a need to get locked in to
 the GC for such simple cases.


 One way is to make x() a function template:

 import std.stdio;

 void x(int y)() {
    bool[y] arr;
    arr[y/2] = true;
    writeln(arr);
 }

 void main() {
     x!5();
 }

 Ali


 But the length depends on runtime behavior.


You said "setting the size at compile time", so I got confused. :)


 Might be 5 or 100. This doesn't handle it, does it?


No, it doesn't handle it. However, if the maximum length is reasonably 
small, then you can create the largest array and use first part of it:

import std.stdio;

enum maxElements = 100;

void foo(int y) {
     bool[maxElements] storage;
     bool[] x = storage[0..y];
     x[y/2] = true;
     writeln(x);
}

void main() {
     foo(5);
}

However, the ~= operator on x would still involve the GC.


 I already make a simple malloc based array that does what I want. Looks
 like a normal array with ~=, [], foreach.


That's basically the same as std.container.Array, which already comes 
with a bool specialization:

import std.stdio;
import std.container;

void foo(int y) {
     auto x = Array!bool();
     x.length = y;
     x[y/2] = true;
     writeln(x[]);
}

void main() {
     foo(5);
}


 Does what I need it to do.  Only works with BasicTypes of course.


I would expect yours to work with user-defined types as well.

Ali
Jun 27 2016
prev sibling parent Johan Engelen <j j.nl> writes:
On Monday, 27 June 2016 at 21:58:04 UTC, "Smoke" Adams wrote:

 I'm in need of a way to create a local array that isn't GC'ed. 
 It must be dynamic in the sense of setting the size at compile 
 time but it will be used only in scope and only on structs.


`alloca` is made for that purpose.
https://dlang.org/library/core/stdc/stdlib/alloca.html

Search for it online to read-up on proper usage so you can avoid 
the caveats.

cheers,
   Johan
Jun 30 2016