Uninitialized variable behaviour in C++

by

How’s this possible when the program always assign a free memory
location to a variable? How could it be something rather than zero?

Let’s take a look at an example practical implementation.

Let’s say it utilizes stack to keep local variables.

void
foo(void)
{
        int foo_var = 42;
}

void
bar(void)
{
        int bar_var;
        printf("%d\n", bar_var);
}

int
main(void)
{
        bar();
        foo();
        bar();
}

Totally broken code above illustrates the point. After we call foo, certain location on the stack where foo_var was placed is set to 42. When we call bar, bar_var occupies that exact location. And indeed, executing the code results in printing 0 and 42, showing that bar_var value cannot be relied upon unless initialized.

Now it should be clear that local variable initialisation is required. But could main be an exception? Is there anything which could play with the stack and in result give us a non-zero value?

Yes. main is not the first function executed in your program. In fact there is tons of work required to set everything up. Any of this work could have used the stack and leave some non-zeros on it. Not only you can’t expect the same value on different operating systems, it may very well suddenly change on the very system you are using right now. Interested parties can google for “dynamic linker”.

Finally, the C language standard does not even have the term stack. Having a “place” for local variables is left to the compiler. It could even get random crap from whatever happened to be in a given register. It really can be totally anything. In fact, if an undefined behaviour is triggered, the compiler has the freedom to do whatever it feels like.

More Related Contents:

  1. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  2. Why is initialization of a new variable by itself valid? [duplicate]
  3. Using newly declared variable in initialization (int x = x+1)?
  4. Is reading an indeterminate value undefined behavior?
  5. Fun with uninitialized variables and compiler (GCC)
  6. Initialization of all elements of an array to one default value in C++?
  7. Initialization Order of Class Data Members
  8. Is uninitialized local variable the fastest random number generator?
  9. May I treat a 2D array as a contiguous 1D array?
  10. Why do constant expressions have an exclusion for undefined behavior?
  11. C++ static member variable and its initialization
  12. Why can’t simple initialize (with braces) 2D std::array? [duplicate]
  13. Why is out-of-bounds pointer arithmetic undefined behaviour?
  14. initialize a const array in a class initializer in C++
  15. Is this infinite recursion UB?
  16. What happens to uninitialized variables? C++
  17. How is static variable initialization implemented by the compiler?
  18. Implementing a std::vector like container without undefined behavior
  19. new() without delete() is Undefined Behavior or merely Memory Leak? [duplicate]
  20. too many initializers for ‘int [0]’ c++
  21. initialization: parenthesis vs. equals sign [duplicate]
  22. At what point does dereferencing the null pointer become undefined behavior?
  23. What’s the difference between parentheses and braces in c++ when constructing objects
  24. When a float variable goes out of the float limits, what happens?
  25. Dangling references and undefined behavior
  26. Initialization difference with or without curly braces in C++
  27. Initializing an std::array of non-default-constructible elements?
  28. Why can’t I initialize a variable-sized array?
  29. What is the order of evaluation in a member initializer list?
  30. C++ default initialization and value initialization: which is which, which is called when and how to reliably initialize a template-type member

Leave a Comment