www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Is `void` the correct way to say "do not initialize this variable"?

reply ryuukk_ <ryuukk.dev gmail.com> writes:
I have tried to look at the documentation and various places on 
the DMD source, but i couldn't find the answer

```D
MyStruct test = void;
```

Does this guarantee that the compiler will not initialize it?

Does it work with static arrays of struct too?

The generated code is different than ``MyStruct test;``

What exactly (by exactly i mean is the behavior documented 
somewhere?) ``void`` does?
Oct 02 2022
next sibling parent reply ryuukk_ <ryuukk.dev gmail.com> writes:
I got the answer thanks to IRC chat: 
https://dlang.org/spec/declaration.html#void_init
Oct 02 2022
parent reply kdevel <kdevel vogtner.de> writes:
On Sunday, 2 October 2022 at 23:37:26 UTC, ryuukk_ wrote:

 I got the answer thanks to IRC chat: 
 https://dlang.org/spec/declaration.html#void_init


Quote:

    Implementation Defined: If a void initialized variable's value 
is used
    before it is set, its value is implementation defined.

Shouldn't this read

    Unspecified Value: If a void initialized variable's value is 
used
    before it is set, its value is unspecified.

?
Oct 03 2022
parent reply Paul Backus <snarwin gmail.com> writes:
On Monday, 3 October 2022 at 14:37:35 UTC, kdevel wrote:

 On Sunday, 2 October 2022 at 23:37:26 UTC, ryuukk_ wrote:

 I got the answer thanks to IRC chat: 
 https://dlang.org/spec/declaration.html#void_init


 Quote:

    Implementation Defined: If a void initialized variable's 
 value is used
    before it is set, its value is implementation defined.

 Shouldn't this read

    Unspecified Value: If a void initialized variable's value is 
 used
    before it is set, its value is unspecified.


Yes, it should. Many of the contributors to the D spec are not 
very well versed in the precise details of these terms, so 
mistakes like this occasionally slip through.
Oct 03 2022
parent kdevel <kdevel vogtner.de> writes:
On Monday, 3 October 2022 at 15:56:02 UTC, Paul Backus wrote:

 Shouldn't this read

    Unspecified Value: If a void initialized variable's value 
 is used
    before it is set, its value is unspecified.


 Yes, it should. Many of the contributors to the D spec are not 
 very well versed in the precise details of these terms, so 
 mistakes like this occasionally slip through.


Issue 23390 - value of void initialized variable is unspecified 
(and not subject to UB)
Oct 06 2022
prev sibling next sibling parent reply drug007 <drug2004 bk.ru> writes:
On 10/3/22 02:30, ryuukk_ wrote:

 I have tried to look at the documentation and various places on the DMD 
 source, but i couldn't find the answer


https://dlang.org/spec/declaration.html#void_init


 
 ```D
 MyStruct test = void;
 ```
 
 Does this guarantee that the compiler will not initialize it?


Yes


 
 Does it work with static arrays of struct too?
 


It works but not as someone could expect. In case of
```
Foo[2] arr = void;
```
`arr` value is not defined, it is not an initialized array of 
uninitialized elements like you want, it is just uninitialized array.


 The generated code is different than ``MyStruct test;``
 
 What exactly (by exactly i mean is the behavior documented somewhere?) 
 ``void`` does?
Oct 02 2022
parent reply tsbockman <thomas.bockman gmail.com> writes:
On Sunday, 2 October 2022 at 23:45:45 UTC, drug007 wrote:

 It works but not as someone could expect. In case of
 ```D
 Foo[2] arr = void;
 ```
 `arr` value is not defined, it is not an initialized array of 
 uninitialized elements like you want, it is just uninitialized 
 array.


This is incorrect. It is not possible to declare an uninitialized 
static array variable in D; only the elements are affected by `= 
void`.

The meta data of a static array like `Foo[2] arr` (`.ptr` and 
`.length`) is determined statically at compile time and inserted 
where needed into the generated code. It is not stored in mutable 
memory the way a dynamic array/slice's meta data is, and does not 
need to be initialized at run time.

By contrast, it **is** possible to declare a completely 
uninitialized dynamic array, or to just leave its elements 
uninitialized:
```D
     // Meta data is not initialized, and no elements are 
allocated.
     // This has no static array equivalent:
     int[] arrA = void;

     // Meta data is initialized, and elements are allocated but 
not initialized.
     // This is the dynamic equivalent of the static:
     // int[2] arr = void;
     int[] arrB = uninitializedArray!(int[])(2);
```
Oct 02 2022
parent drug007 <drug2004 bk.ru> writes:
On 10/3/22 09:35, tsbockman wrote:

 On Sunday, 2 October 2022 at 23:45:45 UTC, drug007 wrote:

 It works but not as someone could expect. In case of
 ```D
 Foo[2] arr = void;
 ```
 `arr` value is not defined, it is not an initialized array of 
 uninitialized elements like you want, it is just uninitialized array.


 
 This is incorrect. It is not possible to declare an uninitialized static 
 array variable in D; only the elements are affected by `= void`.
 
 The meta data of a static array like `Foo[2] arr` (`.ptr` and `.length`) 
 is determined statically at compile time and inserted where needed into 
 the generated code. It is not stored in mutable memory the way a dynamic 
 array/slice's meta data is, and does not need to be initialized at run 
 time.
 


You are right. I used to complex structure (with indirections) for 
testing and made wrong statement.


 By contrast, it **is** possible to declare a completely uninitialized 
 dynamic array, or to just leave its elements uninitialized:
 ```D
      // Meta data is not initialized, and no elements are allocated.
      // This has no static array equivalent:
      int[] arrA = void;
 
      // Meta data is initialized, and elements are allocated but not 
 initialized.
      // This is the dynamic equivalent of the static:
      // int[2] arr = void;
      int[] arrB = uninitializedArray!(int[])(2);
 ```
Oct 03 2022
prev sibling parent tsbockman <thomas.bockman gmail.com> writes:
On Sunday, 2 October 2022 at 23:30:16 UTC, ryuukk_ wrote:

 ```D
 MyStruct test = void;
 ```

 Does this guarantee that the compiler will not initialize it?


It's more of a request, than a guarantee. For example, `= void` 
may be ignored for the fields of `struct`s and `class`es:
```D
struct ABC {
     char a = 'a';
     char b = void;
     char c = 'c';
}

void main()  safe {
     import core.lifetime : emplace;
     import std.stdio : write, writeln;

     ABC abc = { a: 'x', b: 'y', c: 'z' };
     emplace(&abc);
     write(`a: '`, abc.a, `', b: '`);
     if(abc.b != 0)
         write(abc.b);
     else
         write(`\0`);
     writeln(`', c: '`, abc.c, `'`);
}
```

If the `= void` actually prevented initialization of `b`, the 
above would print:
```
a: 'a', b: 'y', c: 'c'
```
However, it actually prints this instead on all D compilers with 
which I tested:
```
a: 'a', b: '\0', c: 'c'
```
This is because it is considered needlessly complicated - and, at 
least for smallish types, possibly actually slower - to support 
uninitialized gaps when blitting `.init` values.


 Does it work with static arrays of struct too?


Yes.
Oct 02 2022