Unexplained C++ default int values

I've been refactoring some cod开发者_运维知识库e and I noticed some wonky behavior involving an uninitialized int array:

int arr[ARRAY_SIZE];

I set a break-point and it seems all values default to -858993460. Is there something special with this value? Any ideas why they don't default to 0?

-858993460 is, in hex, CCCCCCCC, which Visual Studio puts as default in DEBUG MODE. This is to make it easier for you to notice that you forgot to initialize the variable. In release mode it could be anything.

I’m actually unsure why mouseBufferX isn’t an element of 10 items (if this does compile and that isn’t 10 elements). But I am pretty sure that the standard says statics are initialized before nonstatics. Anyways, I personally hate using defines and consts to declare ints. Use an enum instead.

C++ doesn’t default anything to 0, so you MUST assign something a value before using it. Static variables are exceptions to this rule as they are set to zero by default. But I’ll note that the use of static variables is discouraged, and some languages (such as C#) do not allow you to declare static variables in a function.

There is no "default" in C++ -- variables and array elements, until initialized by your code, will contain whatever was in memory last.

In other words, when these variables are declared, a space in memory is reserved for their use. The bits in memory left over from the last time that memory was used are still there, causing your variables to initially appear as if they're filled with "garbage". The reason that memory isn't always zeroed out right away is speed -- it takes time to zero out memory.

You can initialise your array using a loop, or use this trick (at risk of being much less readable):

int mouseBufferX[mosueBufferSize] = { 0 };

This works because when you use a list of values to initialize the array, and there's less literal values than the number of elements in the array, the remaining elements always get initialized to 0.

You need to explicitly set the values for the array - they do not "default" to anything. Try:

memset(mouseBufferX,0,sizeof(mouseBufferX));

//or 

int mouseBufferX[mouseBufferSize] = {0};

//and, in C++ this *might* work too (fuzzy memory!):

int mouseBufferX[mouseBufferSize] = {};

C++ doesn't initialize variables. When a chunk of memory is allocated for the variable, that chunk of memory is left as-is and contains the value it did when it was allocated.

However, some compilers (like g++, I believe) will automatically initialize things to 0 - but don't depend on this behaviour as it will make your code less portable.

To get an array to have all the values in it initialized to a value, you can do this:

int mouseBufferX[mouseBufferSize] = {0};

int mouseBufferY[mouseBufferSize] = {0};

You can provide as many values as you want in the initialization list and the elements will be assigned those values.

Sometimes in a debug build, the compiler will initialize memory to a known value to make it easier to detect bugs. If your compiler does this, it should be documented somewhere.

This is entirely at the discretion of the compiler, because the standard doesn't guarantee any initialization whatsoever in this case.

thats a really dangerous assumption your making.

on a good compiler you might get a constant default value like the closest to -infinity(edit: or 0xCCCCCCCC thx acidezombie24), otherwise you'll just get random numbers

ALWAYS initialize your variables

something like

static const int mouseBufferSize = 10;
int mouseBufferX[mouseBufferSize];
memset(mouseBufferX,0,sizeof(mouseBufferX));
int mouseBufferY[mouseBufferSize];
memset(mouseBufferY,0,sizeof(mouseBufferY));