Recently I refactored some old code of mine, now utilizing classes instead structs, and I got hit by an uninitialized variable access pattern similar to the simplified example below.

How can we easily spot this? What other switches and safeguards are there?

> dmd -dip1000 -debug -g -w

just crashes with `Error: program killed by signal 11` on linux and nothing else.

```d
import std;

@safe:

class Foo { int x; }

void main() {
    Foo f; // = new Foo;
    writeln(f.x);
}
```

On Saturday, 24 September 2022 at 13:17:19 UTC, rassoc wrote:
> just crashes with `Error: program killed by signal 11` on linux and nothing else.

gdb --args ./your_program

and then it will tell you all the details you want to know about when this happens.

strangly sometimes adding the -O option will cause dmd to catch simple cases at compile time but gdb is the general solution to track these down.

On 9/24/22 15:28, Adam D Ruppe via Digitalmars-d-learn wrote:
> gdb --args ./your_program
> 
> and then it will tell you all the details you want to know about when this happens.

Thank you for your input, Adam.  Real shame that there's no built-in compiler solution and probably never will be according to [1]. :(

D's competition got stuff like this right:

```
> crystal build foo.cr
In foo.cr:6:6

 6 | puts f.x
          ^
Error: read before assignment to local variable 'f'
```

[1] https://issues.dlang.org/show_bug.cgi?id=4595

Currently in D you would be forced to create a vtable struct manually.

But if we had something like signatures you could do this:

```d
struct Foo {
	//...
}

struct Bar {
	InputRange input;
}

void doIt() {
	Bar bar;
	Foo* foo = new Foo;
	bar.input = foo;
}
```

Classes are not the only way to do OOP :)

On Monday, 26 September 2022 at 16:51:11 UTC, rikki cattermole wrote:
> Currently in D you would be forced to create a vtable struct manually.

Or I could just use classes.
The cure shouldn't be worse than the disease.

> But if we had something like signatures you could do this:
>
> ```d
> struct Foo {
> 	//...
> }
>
> struct Bar {
> 	InputRange input;
> }
>
> void doIt() {
> 	Bar bar;
> 	Foo* foo = new Foo;
> 	bar.input = foo;
> }
> ```

This would be nice but since we don't it doesn't really matter. unfortunately.