Item — HN Reader

I always find this opinion intriguing, where it's apparently fine that globals are initialized to zero, but you are INSANE to suggest it's the default for locals. What kind of programs are y'all writing?

Clearly the lack of zeroing in C was a trade-off at the time. Just like UB on signed overflow. And now people seem to consider them "obvious correct designs".

2 comments

I'd prefer proper analysis for globals too, but that is substantially harder.

"Improperly using a variable before it is initialized" is a very common class of bug, and an easy programming error to make. Zero-initializing everything does not solve it! It just converts the bugs from ones where random stack frame trash is used in lieu of the proper value into ones where zeroes are used. If you wanted a zero value, it's fine, but quite possibly you wanted something else instead and missed it because of complex initialization logic or something.

What I want is a compiler that slaps me when I forget to initialize a proper value, not one that quietly picks a magic value it thinks I might have meant.

It might be easier to detect a zero value. It might be easier to debug. People used to use hard-coded, human-visible values for debugging for that reason.

Sure, and I'm not against belt-and-suspenders here.

It's just that "all values are defined to be zero-initialized, and you can use them as such" is a horrible decision. It means that you cannot even get best effort warnings for lack of initialization, because as far as the compiler knows you might have meant to use the zero value.

I suspect it's even worse than UB. At least in that case a sanitizer can prevent optimizations and detect the later usage. If default zero initialization is guaranteed then as you say you lose any chance of an automated system detecting the programmer error.

That's what sanitizers are for. Why would you do that manually given the tooling that's freely available?

When I make a logic error the absolute ideal situation is that the compiler rejects the program. The higher the frequency of that result the better.

"What I want is a compiler that slaps me when I forget to initialize a proper value, not one that quietly picks a magic value it thinks I might have meant."

I believed the claim was about whether a compiler would initialize memory to zero. Whatever I said would be done by the compiler.

I don't see how. In the presence of default initialization the compiler cannot diagnose these things, more or less by definition. Therefore you will be falling back on debugging.

UB plus a memory access sanitizer automates the practice that you described.

> was a trade-off at the time

And remains so. When number crunching it is often beneficial to be able to explicitly opt out of initialization for performance reasons.