Thread: 2d array addressing

Is a 2d array always stored contiguously? Will code like the following always give the same results?

Code:

	int matrix[3][3];
	for( int i = 0, k = 0; i < 3; ++i ) {
		for( int j = 0; j < 3; ++j, ++k ) {
			matrix[i][j] = k;
		}
	}
	for( int i = 0; i < 9; ++i ) {
		std::cout << *(matrix[0]+i) << std::endl;
	}

Yes. An array is a contiguous block of memory. In the case of this 2D array, it is a contiguous block of three arrays, which are contiguous blocks of three ints

The catch here is always, particularly if one means "guaranteed."

Arithmetically, it appears good from an eyeball test.

However, matrix[0] is an array of 3 ints, so any access beyond the third element is technically undefined. That is, as soon as i >= 3 is true. Computing the address one past the array is guaranteed, but not accessing it like the code is doing.

There are environments that use array bounds checking (yes, even in C and C++) which could raise an exception to an out-of-bounds access like I described above. Whether that is true in reality or not, or whether that should be a real concern of yours, is arguable.

Originally Posted by whoie

There are environments that use array bounds checking (yes, even in C and C++) which could raise an exception to an out-of-bounds access like I described above.

Well, yes, I mean "guaranteed". Is it guaranteed that the memory for the entire 2d array is contiguous?

By "there are environments ..." were you referring to some specific compiler, or something else?

OK, thanks.

Originally Posted by tabstop

I would be surprised if array-bound checking could find anything wrong with this, since (a) the only index used on the array is 0 and (b) the dereferenced memory addresses lie within the array itself. (Note that the size-pointed-to is what is added; matrix[0] is of type int[3], so it decays to a pointer to int, which means that adding to it adds one int-sized piece at a time.)

I tend to agree with you, and would share your surprise. Certainly nothing posted in that example is something I would consider to be "dancing on glass." Indeed, if we rewrote the expression to be *(&matrix[0][0]+i), I think it would greatly resemble a considerable amount of code from matrix libraries.

However, I do believe it could be argued that it is technically undefined. I say that, because I am not convinced that an (admittedly) heavyweight bounds-checker wouldn't see matrix[0] and consider the underlying type to be "array of 3 int," (which it is). I doubt whether it would actually occur in practice, because those who put considerable value on bounds checking moved far away from C and C++ a long time ago. I simply wanted to point out something that could possibly be undefined, and wouldn't always give the same results. I'm not convinced either way at this point, and it wouldn't stop me from doing that if I had a good reason.