0
#include <stdio.h>

int main(void)
{

    int values[10];
    int index;

    values[0] = 197;
    values[2] = -100;
    values[5] = 350;
    values[3] = values[0]+values[5];
    values[9] = 
    values[5] / 10;
    --values[2];

    for (index = 0; index < 10; index++)
        printf ("values[%i] = %i\n", index, values[index]);

    return 0;
}

Why do I have values in the unassigned elements of 1, 4, and 6-8? I didn't assign any values. How can I make it assign automatically 0 when it's empty?

Jens Gustedt
  • 76,821
  • 6
  • 102
  • 177
Martin
  • 123
  • 1
  • 2
  • 7
  • To add to Oli's answer, just *always* initialize variables. An in your example put the declaration of `index` also inside the first expression of the `for` statement. There are rare circumstances where initializing variables may decrease performance a little bit, but usually this shouldn't be much of a concern. – Jens Gustedt Jan 02 '13 at 08:55

4 Answers4

6

You didn't assign them, so you just get whatever rubbish was already in memory at those locations.

To zero-initialize, you can do this:

int values[10] = {0};

Alternatively, use memset.

Oliver Charlesworth
  • 267,707
  • 33
  • 569
  • 680
4

In C, automatic variables are never zeroed. What you want is to memset() your array to 0 to avoid that.

fge
  • 119,121
  • 33
  • 254
  • 329
3

From C99 you can also initialize only the subobjects you need and the rest will be initialized as data with static storage duration (0 for int):

int values[10] =
{
    [0] = 197,
    [2] = -100,
    [5] = 350,
    [3] = values[0] + values[5],
    [9] = values[5] / 10
};

More complicated initializations are impossible/unclear to do this way. Things like:

--values[2];

Cannot be done in the initialization because if there are more initializers for the same element, only the last will be used and the first ones could not even be evaluated, causing a decrement on an uninitialized value. From C11 standard:

The initialization shall occur in initializer list order, each initializer provided for a particular subobject overriding any previously listed initializer for the same subobject; 151)

151) Any initializer for the subobject which is overridden and so not used to initialize that subobject might not be evaluated at all.

(I think it deserves more than a foot-note...)

However, I think that's just an example since there is no point to do so, you can initialize it to 350 - 1 in this case.

effeffe
  • 2,821
  • 3
  • 21
  • 44
3

While Oli Charlesworth's post shows the solution, let me introduce a little more "why". Such undefined values are very obvious for "automatic" variables allocated on the applications stack.

While operating systems tend to zero memory before loading programs into it main() is not where C programs actually start. The actual starting location is buried in some implementation dependent place making your code in main() just the last call in a series of function calls during program start up. All of these earlier internal calls scribble in the stack leaving their mess behind them.

As each function call inherits the mess from prior calls it's really unknown what will be seen on the stack of a fresh call. If the stack grows large enough you will eventually find the operating system's zeros in unused memory, which may help debugging in lager programs, but code must never depend on such zeros.

Both stack and heap (e.g., malloc()) memory are subject to unknown values.

Gilbert
  • 3,740
  • 17
  • 19