Question

I’m referring to the main static languages today (C, C++, java, C#,). I’ve heard some contradicting answers about this, so I wanted to know:

If I have some code such as:

loop(...) {
  type x = val;
  ...
}

(‘loop’ is some type of loop, e.g. for, while)
Will it cause memory allocation in each iteration of the loop, or just once? Is it different from writing this:

type x;
loop(...) {
  x = val;
  ...
}

where memory is only allocated once for x?

Answer 1

The strictly correct answer is that it depends on the implementation, as both are semantically correct. No language specification would require or prohibit such implementation details.

That said, any implementation worth its salt will be able to reuse the same stack slot or even CPU register (with native compilation, especially likely in presence of a JIT). Even the bytecode will likely be completely identical.

And finally, there’s that thing with premature optimization… Unless proven otherwise, you shouldn’t even bother thinking about low-level details like this (if you think knowledge and control over such issues matters, perhaps you should just program in assembler), because:

• Unless you’re doing a microbenchmark (or a really huge number-crunching task – but how many people freaking out about performance actually do those?), you won’t even notice any difference even if it isn’t optimized. If you’re doing anything of interest in the loop body, it will dwarf the difference (again, if any). Especially if you’re doing any I/O.
• Even if there is memory allocation, it boils down to pushing and popping a few bytes on the native stack, which in turn boils down to adding an integer constant to a hardware register. All C and C++ programs use that stack for their local variables, and non of those ever complained about its performance… if you have to reserve space, you can’t get faster than using the stack.
• If you have to ask this kind of question, you’re not someone who could do anything about it. Those people know to just (1) measure it, (2) look at the generated code and (3) look for large-scale optimizations before even thinking on this level 😉