Pointer to array

1) It contains five sets of 3 elements.
2) The same way that an int * can be assigned a int[5]. An array decays to a pointer to the first element. So an int[5][3] can decay to an int (*)[3].
3) It allocates 5 * 3 * sizeof(int) bytes, and the result of that allocation is assigned to p.
4) Yes.

The thing to understand here is that the fallowing two lines are functionally equal.

p = new int[5][3];
p = new int[3][5];

They both create an array that is actually sizeof(int) * 3 * 5, as SiCrane said.

The thing that's really important is what does p+1 point to?

Quote:

Original post by Splinter of Chaos p = new int[5][3]; p = new int[3][5];

Those two lines should return arrays of different types. You should at least get a warning.

True, maybe, but not that different.

a1 = {{1,2,3},{4,5,6}};
a2 = {{1,2},{3,4},{5,6}};

Besides, I didn't say the lines were the same, so much as functionally the same.

Of course the memory layout will me the same if you fill both with consecutive numbers from the very first element. That would make p = new int[15] just as much the same. But accessing the arrays will give you different values becuase of different dimensions.

The are different, and they are functionally different, becuase they all have different dimensions.

Just because two things will have the same size, and the same bit pattern, in memory at runtime, doesn't make them identical in C++. The type of an object is not generally represented with memory; it's a compile-time concept. int x[5][3] differs from int y[3][5] in that reinterpret_cast<char*>(x[1]) - reinterpret_cast<char*>(x[0]) != reinterpret_cast<char*>(y[1]) - reinterpret_cast<char*>(y[0]).

Quote:

Original post by Zahlman int x[5][3] differs from int y[3][5] in that reinterpret_cast<char*>(x[1]) - reinterpret_cast<char*>(x[0]) != reinterpret_cast<char*>(y[1]) - reinterpret_cast<char*>(y[0]).

Those reinterpret_casts aren't necessary to prove a point:

#include <iostream>int main(){    int x[5][3];    int y[3][5];    std::cout << (x[1] - x[0]) << std::endl;    std::cout << (y[1] - y[0]) << std::endl;}

new int[5][3] and new int[3][5] are functionally the same. I never claimed that int[5][3] x or int[3][5] y was the same. In fact, I never actually said [5][3] and [3][5] were the same. I said they were FUNCTIONALLY THE SAME meaning the assembly code produced that creates the array is the same. Functionally, they are no different.

However, I wanted the OP to answer what p++ meant from his or her example (int (*p)[3];). I didn't want to spark a holy war over semantics.



I think the output is actually pretty interesting.

EDIT

What I think is pretty interesting is how no matter how that is written, the answer is one because the pointer units are one. I forgot that when I copied DevFred's code to test it, but then remembered a lazy way around that was casting to an int. HERE is what I find interesting:


[Edited by - Splinter of Chaos on December 11, 2008 2:18:30 AM]

Quote:

Original post by Splinter of Chaos new int[5][3] and new int[3][5] are functionally the same. I never claimed that int[5][3] x or int[3][5] y was the same. In fact, I never actually said [5][3] and [3][5] were the same. I said they were FUNCTIONALLY THE SAME meaning the assembly code produced that creates the array is the same. Functionally, they are no different.

Personally, I never claimed that you clamined that they were the same. But your definition of "functionally the same" is very strange. Why, for any reason, would the assembly code is required to create the arrays be important in a language designed to abstract assembly language? And how do you know that there's no difference in any of the several platforms in existance, where there's also a C++ compiler? By that definition, everything is the same. The assembly code to create any integer array is the same. So that would make any integer array functionally the same, not just the two you're talking about.

On any level other than the assembly required to allocate the arrays, they are different. Yes, functionally different. The pointer types returned by new are incompatible, and the usages are different.