Thread: help on test quest

Essentially what happened is that you didn't initialize your array (neither your i and j flags).

When one doesn't initialize a variable and it was declared on the global scope, it gets initialized for us. On the case of ints, they get the value 0. So, your array was populated with all 0's. Which means all elements are equal. Your test could not possibly fail.

Here's a test program that I wrote. It compiles on the MinGW port of GCC 3.4.2 and on MSVC8, the program compiled returns acceptable output. My question would then be whether the pointer arithmetic is indeed correct, given that a is a two dimensional array. If it is, then the answer is still that (a)/1 is correct, because (b)/2 is wrong.

Code:

#include <iostream>

int main()
{
	int a[4][3] = { {0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11} };

	for (std::size_t i = 0; i < 4; ++i)
	{
		for (std::size_t j = 0; j < 3; ++j)
		{
			std::cout << a[i][j] << " ";
		}
		std::cout << "\n";
	}
	std::cout << "\n";
	for (std::size_t i = 0; i < 4; ++i)
	{
		for (std::size_t j = 0; j < 3; ++j)
		{
			std::cout << *(&a[0][0] + (3 * i) + j) << " ";
		}
		std::cout << "\n";
	}
}

I think that is correct. According to this page: "Two dimensional arrays are stored in row major order, that is, row by row. Each row contains COLS elements, which is why you see COLS in the formula. In fact, you don't see ROWS"

Code:

   addr( & arr[ row ][ col ] ) = addr( arr ) + [ sizeof( int ) * COLS * row ]
                                             + [ sizeof( int ) * col ]

It seems odd, because if I wanted to store a 2d table in a single dimensional array, I'd usually use x + y*width for the index, but for 2d arrays, it seems you have to use y + x*height.

Originally Posted by Mario F.

1. an array name is actually a pointer to the first position in the array

Not exactly. (As in, no, an array is not a pointer.)
http://c-faq.com/aryptr/constptr.html

I said array name
An array is not a pointer. An array name is a pointer to the first element in the array.

Code:

int arr[5] = {1,2,3,4,5};

std::cout << *(arr + 1) << std::endl;

or more explicitly:

Code:

int arr[3] = {1,2,3};

int *p = arr;

An array is not a pointer. An array name is a pointer to the first element in the array.

An array name represents the array. An array decays to a pointer to its first element.
Consider:

Code:

int arr[5] = {1,2,3,4,5};

std::cout << sizeof(arr) << std::endl;

If indeed an "array name is a pointer to the first element in the array", then you would expect sizeof(arr) to be the same as sizeof(int*). However, it would be the same as (sizeof(int) * 5) since arr has not decayed to a pointer to its first element.

Originally Posted by Mario F.

I said array name
[...] An array name is a pointer to the first element in the array.

Look!The name of an int is really a double!

Code:

#include <iostream>

int main()
{
   int i = 5;
   double d = i;
   std::cout << "d = " << d << '\n';
   return 0;
}

Or, no, such oversimplifications are simply false.

Under certain conditions an array is converted to a pointer to the first element (as already mentioned).

Originally Posted by laserlight

hmm... suppose i = j = 0.
*(&a[0][0] + 4*0 + 0 - 1) => *(&a[0][0] - 1)

This looks like one is trying to dereference a pointer that points to one before the first element.
...............

In this case a[0][0] is an lvalue, so &a[0][0] is valid. (&a[0][0] + 4*i + j) is just pointer arithmetic, and results in a pointer. Hence using unary operator* on it should be valid, assuming that the pointer is valid.

So, int a[4][3], the last element is a[3][2].
When i =3, j = 2, *(&a[0][0] + 4*3 + 2) => *(&a[0][0]+14) = exceeds the array.
I think that it's correct if we modify it as following : a[i][j] ==*(&a[0][0] + 3i + j), and it works with all i in [0,3] and j in [0,2].
Am I correct ?

Edit:
I think a[0][0] is the pointer point to the first collumn of this array. That means it is the pointer of the array of pointers to each row of the array. This following declares an 4x3 array :

Code:

int **p = new int[4]; //create an one-dimemtion array of pointer type int, which is pointed to by a pointer p.
for (int i=0;i<4;i++)
   p[i] = new int[3]; //create 3 element for each row.

So &a[0][0] is referent to a. My feeling is that the compile would create an anonymous array variable that has the same address as a[0][0]. Thus, *(&a[0][0]) is dereferencing to the value of a.

I do'nt know if I am right or wrong, but I just want to learn more by participating any discussion.

Originally Posted by Dave_Sinkula

Under certain conditions an array is converted to a pointer to the first element (as already mentioned).

Yes. I had to go back to Stroustrup's (page 92). I had misread this information when I first went through it. I apologize

So, int a[4][3], the last element is a[3][2].
When i =3, j = 2, *(&a[0][0] + 4*3 + 2) => *(&a[0][0]+14) = exceeds the array.
I think that it's correct if we modify it as following : a[i][j] ==*(&a[0][0] + 3i + j), and it works with all i in [0,3] and j in [0,2].
Am I correct ?

Yes. Notice that is what I used in my test program.