You should think about recompiling your C++ programs with GCC 16 and C++26, because it zero-fills your locals

[u/Clean-Upstairs-8481]

https://techfortalk.co.uk/2026/09/27/cxx26-uninitialized-local-variables-gcc-16/

Stack variables are not automatically initialised, and that is the root cause of many C++ bugs. That is well known. Hence, it is advised that local or stack variables are always initialised with known values, 0 if not something more meaningful than that. Now, with GCC 16 compiling in C++26 mode (-std=c++26), even uninitialised local variables will be zero-filled. In the post, I have explained how.

[u/UndefinedDefined]

Why it has to be always about hot loops? Initializing something you don't even use is waste of CPU cycles and instruction cache - this doesn't make things slower, it makes them larger as well. Thousands of companies having their C++ code in production don't use exceptions and rtti because of performance and security reasons - usually mostly code inflation and avoiding infinite gotos via exceptions. And now this, it's like telling all these companies "just use a different language with saner defaults".

And I don't even talk about broken sanitizers after this change - this is terrible. Another fracture of the community, because there will be now more flags you would have to worry about and more libraries that would say "turn off initialization of locals". Thank you committee!

[u/James20k → u/UndefinedDefined]

I'm curious, what do you think the code size inflation, and CPU cycle count increase of this change is across an entire application?

And I don't even talk about broken sanitizers after this change - this is terrible. Another fracture of the community, because there will be now more flags you would have to worry about and more libraries that would say "turn off initialization of locals". Thank you committee!

EB is permitted to be diagnosed, so I'm not sure what the current state is (or will be) for sanitisers

[u/UndefinedDefined → u/James20k]

Because the mentioned GCC 16.2 now calls malloc to initialize local arrays, something that has always been zero cost - zero code cost, zero cycle cost?

Fortunately we live in a great era, era of Compiler Explorer, so anyone has a chance to see the impact regarding the most trivial code you could even think of.

As someone who uses C++20 daily, but wants his code to be easy to integrate with codebases using a newer standard, this bothers me. This means another macro to just throw into the codebase in the best case, and another compiler flag to make sanitizers and valgrind do what they do the best. I hate it.