Uninitialized variable

From Wikipedia, the free encyclopedia

This article does not cite any references or sources. (December 2007) Please help improve this article by adding citations to reliable sources. Unverifiable material may be challenged and removed.

In computing, an uninitialized variable is a variable that is declared but is not set to a definite known value before it is used. It will have some value, but not a predictable one. As such it is a programming error and a common source of bugs in software.

A common assumption made by novice programmers is that variables are set to a known value, such as zero, when they are declared. While this is true for many languages, it is not true for all of them, and so the potential for error is there. Languages such as C use stack space for variables, and the collection of variables allocated for a subroutine is known as a stack frame. While the computer will set aside the appropriate amount of space for the stack frame, it usually does so simply by adjusting the value of the stack pointer, and does not set the memory itself to any new state. Therefore whatever contents of that memory at the time will appear as initial values of the variables which occupy those addresses.

Here's a simple example in C:

void count( void )
{
    int k, i;
 
    for(i=0; i<10; i++)
        k = k+1; 
 
    printf("%d", k);
}

What is the final value of k? The fact is, it is impossible to tell. The answer that it must be 10 assumes that it started at zero, which may or may not be true. Note that in the example, the variable i is initialized to zero by the first element of the for statement.

In C global uninitialized variables are in .bss section with GNU compiler and it will be initialized as 0 by system when program starts to run.

Not only are uninitialized variables a frequent cause of bugs, but this kind of bug is particularly serious because it may not be reproducible; in some cases, programs with uninitialized variables may even pass SQA.

Many modern compilers will attempt to identify uninitialized variables and report them as compile-time errors. This is a very valuable capability. It is important to read the compiler documentation carefully, as there may be unexpected limitations. For example, the warning may not be on by default; the warning may be issued only when generating optimized code; and the warning may not be reliable (it may fail to detect all cases of uninitialized variables, or it may issue warnings where variables are actually are initialized before use but only as a result of complex logic paths).

Uninitialized variables are a particular problem in languages such as assembly language, C, and C++, which were designed for systems programming. The development of these languages involved a design philosophy in which conflicts between performance and safety were generally resolved in favor of performance. The programmer was given the burden of being aware of dangerous issues such as uninitialized variables. In academically-designed languages, and languages intended for use by students, applications programmers, and other "mere mortals," variables are often initialized to known values when created.

Some languages, like Java, do not have uninitialized variables. In Java, fields of classes and objects that do not have an explicit initializer and elements of arrays are automatically initialized with the default value for their type (false for boolean, 0 for all numerical types, null for all reference types). Local variables in Java must be definitely assigned to before they are accessed, or it is a compile error.