一些基本的C ++概念-初始化和赋值

Question

I was asked in an interview, to tell the exact difference for the following c/c++ code statements

int a = 10;

and

int a;
a = 10;

Though both assign the same value, they told me there is a lot of difference between the two in memory.

Can anyone please explain to me about this?

Answer 1

As far as language concerned, they are two ways to do the same thing, initialize the variable a and assign 10 to it.

The statement int a; reserves memory for the value a which certainly contains garbage.

Because of that you initialize it with a = 10;

In the statement int a = 10; these two steps are done in the same statement.

First a part of memory is reserved to the variable a , and then the memory is overwritten with the value of 10 .

int a                                     =  10;
^^^^^                                     ^^^^^
reserve memory for the variable a         write 10 to that memory location

Regarding memory the first declaration uses less memory on your PC because less characters are used, so your .c file will be smaller.

But after compilation the produced executable files will be the same .

IMPORTANT : if those statements are outside any function they are possibly not the same (although they will produce the same result).

The problem is that the first statement will assign 0 to a in the first statement because most compilers do that to global variables in C (and is defined by C standard).

Answer 2

"Though both assign the same value, but there is a lot of difference between the two in memory."

No, there's no difference in stack memory usage!
The difference is that assigning a value though initialization may cause some extra cost for additional assembler instructions (and thus memory needed to store it, aka. code footprint ), the compiler can't optimize out at this point (because it's demanded).

If you initialize a immediately this will have some cost in code. You might want to delay initialization for later use, when the value of a is actually needed:

void foo(int x) {
    int a; // int a = 30; may generate unwanted extra assembler instructions!

    switch(x) {
    case 0:
        a = 10;
        break;
    case 1:
        a = 20;
        break;
    default:
        return;
    }

    // Do something with a correctly initialized a
}

This could have well been an interview question made to you in our company, by particular colleagues of mine. And they'd wanted you to answer, that just having the declaration for int a; in 1st place is the more efficient choice.

I'd say this interview question was made to see, if you're really have an in-depth understanding of c and c++ language (A mean-spirited though!).

---

Speaking for me personally, I'm more convenient on interviews about such stuff usually.

I consider the effect is just very minimal. Though it could well seriously matter on embedded MCU targets, where you have very limited space left for the code footprint (say less/equal than 256K), and/or need to use compiler toolchains that actually aren't able to optimize this out for themselves.

Answer 3

If you are talking about a global variable (one that doesn't appear in a block of code, but outside of all functions/methods):

int a;

makes a zero-initialized variable. Some (most?) c++ implementations will place this variable in a memory place (segment? section? whatever it is called) dedicated for zero-initialized variables.

int a = 10;

makes a variable initialized to something other than 0. Some implementations have a different region in memory for these. So this variable may have an address ( &a ) that is very different from the previous case.

This is, I guess, what you mean by "lot of difference between the two in memory".

Practically, this can affect your program if it has severe bugs (memory overruns) - they may get masked if a is defined in one manner or the other.

PS To make it clear, I am only talking about global variables here. So if your code is like int main() {int a; a = 10;} int main() {int a; a = 10;} - here a is typically allocated on stack and there is no "difference in memory" between initialization and assignment.