www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - static arrays at runtime with templates ?

reply Emil <emilper gmail.com> writes:
I tried this on a whim and it appears to work:

auto static_array(T, size_t data_size)()
{
     T[data_size] data;
     return data;
}

void main() {
     import std.stdio: writeln;
     import std.traits: isStaticArray;

     auto data = static_array!(int, 5)(3);
     writeln(data);
     static assert(__traits(isStaticArray, data));

     auto data_longer = static_array!(int, 6)(2);
     writeln(data_longer);
     static assert(__traits(isStaticArray, data_longer));
}


Is this for real, static arrays at runtime without manually 
allocating memory ? Is this legitimate or should I expect 
problems ?
Feb 03
next sibling parent reply Paul Backus <snarwin gmail.com> writes:
On Sunday, 3 February 2019 at 16:33:48 UTC, Emil wrote:
 I tried this on a whim and it appears to work:

 auto static_array(T, size_t data_size)()
 {
     T[data_size] data;
     return data;
 }
This is actually already in the standard library: https://dlang.org/phobos/std_array.html#staticArray
Feb 03
parent Emil <emilper gmail.com> writes:
On Sunday, 3 February 2019 at 16:36:30 UTC, Paul Backus wrote:
...
 This is actually already in the standard library:

 https://dlang.org/phobos/std_array.html#staticArray
thank you either I already read that and forgot or finally I'm starting to get the feel of the language :)
Feb 03
prev sibling parent reply XavierAP <n3minis-git yahoo.es> writes:
On Sunday, 3 February 2019 at 16:33:48 UTC, Emil wrote:
 Is this for real, static arrays at runtime without manually 
 allocating memory ? Is this legitimate or should I expect 
 problems ?
Static arrays are always allocated at run-time. It's the size of the array that must be known at compile-time (in this case via a template parameter). What's the advantage (or the essential difference) of auto data = static_array!(int, 5); instead of int[5] data; ? Just asking ;) but it's good to play. What does not compile on my end are the run-time parameters (3) and (2)...?
Feb 04
parent reply Emil <emilper gmail.com> writes:
On Monday, 4 February 2019 at 16:08:38 UTC, XavierAP wrote:
 Static arrays are always allocated at run-time. It's the size 
 of the array that must be known at compile-time (in this case 
 via a template parameter).

 What's the advantage (or the essential difference) of
     auto data = static_array!(int, 5);
 instead of
     int[5] data;
 ? Just asking ;) but it's good to play.

 What does not compile on my end are the run-time parameters (3) 
 and (2)...?
you are correct ... 24 hours of being very satisfied with myself were good, but also good thing I did not quit and start looking for a D job Can std.array.staticArray build static arrays with size known only at run time ? Now that I am not overcome with enthousiasm it looks like it too needs to know the size.
Feb 04
next sibling parent "H. S. Teoh" <hsteoh quickfur.ath.cx> writes:
On Mon, Feb 04, 2019 at 07:14:38PM +0000, Emil via Digitalmars-d-learn wrote:
[...]
 Can std.array.staticArray build static arrays with size known only at
 run time ? Now that I am not overcome with enthousiasm it looks like
 it too needs to know the size.
That's not possible, because the size of a static array is part of its type, meaning it must be known at compile-time. Perhaps what you're looking for is alloca (and possibly a slice over that)? T -- In a world without fences, who needs Windows and Gates? -- Christian Surchi
Feb 04
prev sibling parent reply XavierAP <n3minis-git yahoo.es> writes:
On Monday, 4 February 2019 at 19:14:38 UTC, Emil wrote:
 Can std.array.staticArray build static arrays with size known 
 only at run time ? Now that I am not overcome with enthousiasm 
 it looks like it too needs to know the size.
A static array's size must be known (or computed) at compile time, by definition... There can be no exception; staticArray() gets or infers the size from its template/compile-time arguments. For one, the trivial example on dlang.org/phobos auto a = [0, 1].staticArray; static assert(is(typeof(a) == int[2])); is equivalent to int[2] a = [0, 1]; static assert(is(typeof(a) == int[2])); Is it better? Depends on.....? No it really isn't... However one of the possibilities of D is the ability to generate and execute quite some code at compile time by means of meta-programming; and I guess here's where staticArray() may end up being useful enough to have merited introduction into the std library; not for trivial uses where a straightforward T[n] declaration is preferable, being possible... If there is something you want to solve in a program of yours, there may be another way, as H.S. Teoh suggests. If you're just trying out stuff it's also fine, :) there's still more.
Feb 04
next sibling parent Emil <emilper gmail.com> writes:
On Monday, 4 February 2019 at 22:48:10 UTC, XavierAP wrote:
...
 If there is something you want to solve in a program of yours, 
 there may be another way, as H.S. Teoh suggests. If you're just 
 trying out stuff it's also fine, :) there's still more.
Since August last year I try to read or write a bit of D code every day. I'm still trying out stuff and going through the books. In this case I was way too excited about passing both types and data to a template and having it compile the first time I tried, and jumped to conclusions. Thank you for pointing where my confusion was.
Feb 05
prev sibling parent Paul Backus <snarwin gmail.com> writes:
On Monday, 4 February 2019 at 22:48:10 UTC, XavierAP wrote:
 However one of the possibilities of D is the ability to 
 generate and execute quite some code at compile time by means 
 of meta-programming; and I guess here's where staticArray() may 
 end up being useful enough to have merited introduction into 
 the std library; not for trivial uses where a straightforward 
 T[n] declaration is preferable, being possible...
The main benefit of staticArray is that it allows the length of the array to be inferred from the initializer (like in C).
Feb 05