Simple C program, weird output

Question

In this simple C program, when I comment Line Y and leave Line X as is, the output of the call to f() outputs 0 and Line B outputs some random number. When I comment Line X and uncomment Line Y, then the output is some random number because of Line B and another random number because of Line Y. However, when I comment Line A and Line B, both calls to f() output 0. Can someone explain to me why this is the case? Thank you in advance. By the way, I'm using gcc without any flags and running this on macOS Catalina.

#include <stdio.h>

void f() {
    int x;
    printf("%d\n", x);
}

int main() {
    f();               // Line X
    int a;             // Line A
    printf("%d\n", a); // Line B
    f();               // Line Y
    return 0;
}

X and a are uninitialized stack variables. Their value is whatever happens to be in that stack location at the time. Change the code, change the stack. This is what it’s called undefined behavior. — Mark Tolonen, Jul 11 '20 at 03:36
You're right, but each time I run it, the first call to ```f()``` always outputs ```0```, which I find really weird. And when I comment Line A and B, both calls to ```f()``` output ```0```. — Gabriel S, Jul 11 '20 at 03:38
It’s undefined behavior, not necessarily unpredictable behavior for a particular compiler. It may always start with a zeroed stack. Calling functions writes to the stack and changes its state. — Mark Tolonen, Jul 11 '20 at 03:38
Fun fact: the compiler is allowed to, and some really will, discard *all of the code* in this program, because the only way it doesn't have undefined behavior is if it's never run, so it must never be run, so all of the code is unreachable... — zwol, Jul 11 '20 at 03:44
I don't have a Mac so I can't try this, but it would be interesting to run your program under a debugger, placing breakpoints at each of your functions and at printf, and displaying the value of the stack pointer register each time the program stops. That will show the extent of the garbage being left on the stack after each function returns. — Mark Plotnick, Jul 11 '20 at 03:46
Does this answer your question? [Undefined, unspecified and implementation-defined behavior](https://stackoverflow.com/questions/2397984/undefined-unspecified-and-implementation-defined-behavior) — PiRocks, Jul 11 '20 at 04:05

score 5 · Accepted Answer · answered Jul 11 '20 at 03:40

When you do this:

int x;
printf("%d\n", x);

You are allocating space on the stack for x and then printing its value. That value could theoretically be anything (you can't expect it to be zero, or any particular value), but in practice it will be whatever value happened to be there on the stack before.

This is why changing the surrounding code changes the value of x, because the stack is used by other parts of your program, and changing those parts leaves different values sitting in that space in the stack where x happens to be allocated.

You may also get different values of x when you change compiler options, or use a different computer.

You may be wondering why removing "Line A" alters the output of "Line X" which comes before "Line A." That is because the compiler may do all stack allocations for main at the start of the function instead of line-by-line (e.g. it allocates space for a before x, thus altering the value you see when you print x, because it has shifted "down" one space on the stack).

Simple C program, weird output

1 Answers1