Does it matter when variables are initialised?

Question

Is there a difference in C++ between the following, with regards to the amount and efficiency in space and time utilisation, and does the answer depend on the compiler?

int main() {
    int a, b = 0;
    doSomething1(b);
    a = 9;
    doSomething2(a);
    return 0;
}
int main() {
    int a = 0, b = 0;
    doSomething1(b);
    a = 9;
    doSomething2(a);
    return 0;
}
int main() {
    int b = 0;
    doSomething1(b);
    int a = 9;
    doSomething2(a);
    return 0;
}

Edit: This question has been marked as a duplicate of this, which in my opinion is incorrect because

1. The other question is asking if variables - regardless of where they are used in a function - should be declared at the very start, or if they should be declared only within the code block where it is used (i.e. the most local scope).
2. My question is asking if there is a performance difference, space- or time-wise, to initializing variables at the very start of a function, or only at the point where it is needed in the same scope.

Please review the flag on this question. It's not a duplicate.

Answer 1

In principle, any C++11 conforming implementation should show equivalent behavior (and what "equivalent" means is difficult to grasp, the tricky notion being : undefined behavior).

In practice, I believe that it is better to initialize every variable at (or near) its declaration (like your second example). The code is probably easier to read and will show more deterministic behavior.

With recent GCC, when compiling with g++ -std=c++11 -Wall -Wextra -g, you'll get useful warnings about uninitialized variables.

Regarding performance, when asked to optimize (e.g. g++ -std=c++11 -O2) the compiler will remove useless initializations - notably for local variables - (hence always initializing variables does not practically impact the performance of generated code).

My question is asking if there is a performance difference, space- or time-wise, to initializing variables at the very start of a function, or only at the point where it is needed in the same scope

Probably no practical difference in performance, but the C++11 standard does not care much about performance (and care much more about compliance). Performance is a quality of implementation issue.

If you care that much about performance, you'll need to benchmark. But don't forget to enable optimizations in your compiler (e.g. g++ -march=native -O2); I guess you won't be able to notice any significant performance difference (so, if you measure reliably some difference, it probably would be a small fraction of percent).

Please look inside the generated assembler code (e.g. with g++ -S -fverbose-asm -O2, then look into the *.s generated assembler file). With GCC you might also pass -fdump-tree-all to get hundreds of dump files explaining what optimizations happened (but you'll spend days in studying them).