ubyte[5] a = 0xAA; // Fine. Five 0xAA bytes.
auto a2 = new ubyte[5]; // Fine. Five 0 bytes.
Now, let's say, I want to allocate an array of a size, derived at run time, and initialize it to some non-zero value at the same time. What would be the shortest way of doing it?

On Wednesday, 10 June 2015 at 20:22:18 UTC, Adel Mamin wrote:
> ubyte[5] a = 0xAA; // Fine. Five 0xAA bytes.
> auto a2 = new ubyte[5]; // Fine. Five 0 bytes.
> Now, let's say, I want to allocate an array of a size, derived at run time, and initialize it to some non-zero value at the same time. What would be the shortest way of doing it?

Assign void, then assign whatever?

On Wednesday, 10 June 2015 at 20:22:18 UTC, Adel Mamin wrote:
> ubyte[5] a = 0xAA; // Fine. Five 0xAA bytes.
> auto a2 = new ubyte[5]; // Fine. Five 0 bytes.
> Now, let's say, I want to allocate an array of a size, derived at run time, and initialize it to some non-zero value at the same time. What would be the shortest way of doing it?

Probably:

auto a2 = value.repeat(size).array;

On 06/10/2015 01:22 PM, Adel Mamin wrote:
> ubyte[5] a = 0xAA; // Fine. Five 0xAA bytes.
> auto a2 = new ubyte[5]; // Fine. Five 0 bytes.
> Now, let's say, I want to allocate an array of a size, derived at run
> time, and initialize it to some non-zero value at the same time. What
> would be the shortest way of doing it?

Another option:

void main()
{
    auto a2 = new ubyte[5];
    a2[] = 0xAA;    // <-- Assign to "all elements"

    /* Alternative syntax:
     *
     *    auto a2 = new ubyte[](5);
     */
}

Ali

On Wednesday, 10 June 2015 at 22:03:52 UTC, Ali Çehreli wrote:
> Another option:
>
> void main()
> {
>     auto a2 = new ubyte[5];

But this causes an extra zero-initialization of a2.

>     a2[] = 0xAA;    // <-- Assign to "all elements"

Is

    auto a2 = value.repeat(size).array;

better in this regard?

On Wed, 10 Jun 2015 20:22:17 +0000
Adel Mamin via Digitalmars-d-learn <digitalmars-d-learn@puremagic.com>
wrote:

> ubyte[5] a = 0xAA; // Fine. Five 0xAA bytes.
> auto a2 = new ubyte[5]; // Fine. Five 0 bytes.
> Now, let's say, I want to allocate an array of a size, derived at
> run time, and initialize it to some non-zero value at the same
> time. What would be the shortest way of doing it?

import std.stdio;

struct Ubyte(ubyte defval) {
    ubyte v = defval;
    alias v this;
}

void main() {
	auto a2 = new Ubyte!(0xAA)[5];
	writeln(a2);
}

On Thursday, 11 June 2015 at 07:57:47 UTC, Per Nordlöw wrote:
> On Wednesday, 10 June 2015 at 22:03:52 UTC, Ali Çehreli wrote:
>> Another option:
>>
>> void main()
>> {
>>    auto a2 = new ubyte[5];
>
> But this causes an extra zero-initialization of a2.
>
>>    a2[] = 0xAA;    // <-- Assign to "all elements"
>
> Is
>
>     auto a2 = value.repeat(size).array;
>
> better in this regard?

Yes, it uses `uninitializedArray()` if the length is known (which it is for `repeat()`):
https://github.com/D-Programming-Language/phobos/blob/master/std/array.d#L111

On Thursday, 11 June 2015 at 08:33:46 UTC, Daniel Kozák wrote:
> On Wed, 10 Jun 2015 20:22:17 +0000
> Adel Mamin via Digitalmars-d-learn <digitalmars-d-learn@puremagic.com>
> wrote:
>
>> ubyte[5] a = 0xAA; // Fine. Five 0xAA bytes.
>> auto a2 = new ubyte[5]; // Fine. Five 0 bytes.
>> Now, let's say, I want to allocate an array of a size, derived at run time, and initialize it to some non-zero value at the same time. What would be the shortest way of doing it?
>
> import std.stdio;
>
> struct Ubyte(ubyte defval) {
>     ubyte v = defval;
>     alias v this;
> }
>
> void main() {
> 	auto a2 = new Ubyte!(0xAA)[5];
> 	writeln(a2);
> }

I like this one :-)

On Thu, 11 Jun 2015 11:43:25 +0000
via Digitalmars-d-learn <digitalmars-d-learn@puremagic.com> wrote:

> On Thursday, 11 June 2015 at 08:33:46 UTC, Daniel Kozák wrote:
> > On Wed, 10 Jun 2015 20:22:17 +0000
> > Adel Mamin via Digitalmars-d-learn
> > <digitalmars-d-learn@puremagic.com>
> > wrote:
> >
> >> ubyte[5] a = 0xAA; // Fine. Five 0xAA bytes.
> >> auto a2 = new ubyte[5]; // Fine. Five 0 bytes.
> >> Now, let's say, I want to allocate an array of a size, derived
> >> at run time, and initialize it to some non-zero value at the
> >> same time. What would be the shortest way of doing it?
> >
> > import std.stdio;
> >
> > struct Ubyte(ubyte defval) {
> >     ubyte v = defval;
> >     alias v this;
> > }
> >
> > void main() {
> > 	auto a2 = new Ubyte!(0xAA)[5];
> > 	writeln(a2);
> > }
> 
> I like this one :-)

small enhancment:
struct Ubyte(ubyte defval = 0)

On Thursday, 11 June 2015 at 07:57:47 UTC, Per Nordlöw wrote:
> On Wednesday, 10 June 2015 at 22:03:52 UTC, Ali Çehreli wrote:
>> Another option:
>>
>> void main()
>> {
>>    auto a2 = new ubyte[5];
>
> But this causes an extra zero-initialization of a2.

just an fyi, gdc optimizes this away(looks like it overwrites the typeinfo,) ldc does not.