C ++，为什么多维数组中一个元素的增加似乎正在增加另一个元素？

Question

This may not be elegant. Chiefly because I am relatively new to C++, but this little program I am putting together is stumbling here.

I don't get it. Have I misunderstood arrays? The edited code is:

int diceArray [6][3][1] = {};

...

}else if (y >= xSuccess || x >= xSuccess){

// from here...

    diceArray[2][1][0] = diceArray[2][1][0] + 1;
    diceArray[2][1][1] = diceArray[2][1][1] + 1;

// ...to here, diceArray[2][2][0] increases by 1. I am not referencing that part of the array at all. Or am I?

}

By using comments I tracked the culprit down to the second expression. If I comment out the first one diceArray[2][2][0] does not change.

Why is diceArray[2][1][1] = diceArray[2][1][1] + 1 causing diceArray[2][2][0] to increment?

I tried..

c = diceArray[2][1][1] + 1;

diceArray[2][1][1] = c;

..as a workaround but it was just the same. It increased diceArray[2][2][0] by one.

Answer 1

You are indexing out of bounds. If I declare such an array

int data [3];

Then the valid indices are

data[0]
data[1]
data[2]

The analog to this is that you declare

int diceArray [6][3][1]
                     ^

But then try to assign to

diceArray[2][1][0]
                ^

diceArray[2][1][1]     // This is out of range
                ^

Since you are assigning out of range, due to pointer arithmetic you are actually assigning to the next dimension due to striding, etc.

Answer 2

The variable is declared as:

int diceArray [6][3][1] = {};

This is how it looks like in memory:

+---+                       -.
|   |  <- diceArray[0][0]     \
+---+                          \
|   |  <- diceArray[0][1]       > diceArray[0]
+---+                          /
|   |  <- diceArray[0][2]     /
+---+                       -'
|   |  <- diceArray[1][0]     \
+---+                          \
|   |  <- diceArray[1][1]       > diceArray[1]
+---+                          /
|   |  <- diceArray[1][2]     /
+---+                       -'
  .            .                      .
  .            .                      .
  .            .                      .
+---+                       -.
|   |  <- diceArray[5][0]     \
+---+                          \
|   |  <- diceArray[5][1]       > diceArray[5]
+---+                          /
|   |  <- diceArray[5][2]     /
+---+                       -'

The innermost component of diceArray is an array of size 1 . C / C++ arrays are always indexed starting from 0 and that means the only valid index in and array of size 1 is 0 .

During the compilation, a reference to diceArray[x][y][z] is converted using pointer arithmetic to offset x*3*1+y*1+z ( int values) using the memory address of diceArray as base.

The code:

diceArray[2][1][1] = diceArray[2][1][1] + 1;

operates on offset 8 (=2*3*1+1*1+1) inside diceArray . The same offset is computed using diceArray[2][2][0] , which is a legal access inside the array.

The modern compilers are usually able to detect this kind of errors and warn you on the compilation.