stuck with a trivia
-
Smith# wrote:
*pyp2 = first row. **pyp2 = first element of the first row.
Wrong. I have tried to explain it in my previous post.
«_Superman_»
Now when you say *pyp2 it is taking the first value of 0 which it thinks is another address. Yes. that's the address of the first pointer. I called it as 1st row. With **pyp2, I try to access the first element. in other words, *pyp2[0]. I agree that you cannot ask it go to the next pointer since it doen't know where first one ends. But what's the problem to access the "first-most" element? We have the address, what's the problem with taking it's address? Am I still missing something?
:beer:
-
Now when you say *pyp2 it is taking the first value of 0 which it thinks is another address. Yes. that's the address of the first pointer. I called it as 1st row. With **pyp2, I try to access the first element. in other words, *pyp2[0]. I agree that you cannot ask it go to the next pointer since it doen't know where first one ends. But what's the problem to access the "first-most" element? We have the address, what's the problem with taking it's address? Am I still missing something?
:beer:
To access the first element you simply do *pyp2. Try it.
«_Superman_»
-
To access the first element you simply do *pyp2. Try it.
«_Superman_»
-
argh okay. accepted. is there way I can do it? I think it can be done by allocating a memory of that dimension dynamically and assigning the pointers one by one.bullshit. I meant assigning the pointers.
:beer:
modified on Wednesday, February 4, 2009 4:02 AM
Try initialising pyp2 like this:
int p1[2] = { 1, 2 };
int p2[2] = { 1, 2 };
int* pyp2[2] = { p1, p2 };pyp2 is of type
(int*)[2], which is equivalent toint **. -
It is giving me the value. Try to understand that this is exactly why your code is crashing.
«_Superman_»
-
Try initialising pyp2 like this:
int p1[2] = { 1, 2 };
int p2[2] = { 1, 2 };
int* pyp2[2] = { p1, p2 };pyp2 is of type
(int*)[2], which is equivalent toint **. -
Try initialising pyp2 like this:
int p1[2] = { 1, 2 };
int p2[2] = { 1, 2 };
int* pyp2[2] = { p1, p2 };pyp2 is of type
(int*)[2], which is equivalent toint **. -
It is giving me the value. Try to understand that this is exactly why your code is crashing.
«_Superman_»
-
//Works
int py[5] = {0,1,2,3,4}; int* pyp = (int*)py;//py printf("%d",pyp[2]);//Doesn't.show "2Dpointer\n"; int py2[2][2] = {0,1,2,3}; int **pyp2 = (int**)py2; printf("py2:%d",py2); printf("pyp2:%d",pyp2); printf("**pyp2[0][0]",pyp2[0][0]);//Crash printf("**pyp2%d",**pyp2);//Crash `why? :beer: `The key point is that arrays and pointers are NOT the same. An array can be converted into a pointer and pointer arithmetic (and indexing) looks the same as array subscripting, but they aren't. They coincide only for linear indexing (that's the case of monodimensional arrays) int **pyp2 is a "[pointer to a [pointer to [an int]]]" The memory layout it expects is like
int** ----> [int*, int*, int*, ...]
| | |
| | |
| | V
| V [int,int,...]
V [int,int,int...]
[int, int, ...]While int py2[2][2] is an "[array of [array of [int]]]" The memory layout it expects is like
[[int,int],[int,int]]
That's completely different.
2 bugs found. > recompile ... 65534 bugs found. :doh:
-
The key point is that arrays and pointers are NOT the same. An array can be converted into a pointer and pointer arithmetic (and indexing) looks the same as array subscripting, but they aren't. They coincide only for linear indexing (that's the case of monodimensional arrays) int **pyp2 is a "[pointer to a [pointer to [an int]]]" The memory layout it expects is like
int** ----> [int*, int*, int*, ...]
| | |
| | |
| | V
| V [int,int,...]
V [int,int,int...]
[int, int, ...]While int py2[2][2] is an "[array of [array of [int]]]" The memory layout it expects is like
[[int,int],[int,int]]
That's completely different.
2 bugs found. > recompile ... 65534 bugs found. :doh:
As you know pointers & arrays both move consecutive. Then how come it be totally different? To some extent I can agree. Because the next pointer in the **ptr can be made to point to some other *p pointing somewhere. But here that's not the case.. it's array, quite consecutive and we are making our **ptr point to it. What do you think about the below approach ? getting the address of the first row pointer & getting the address of it and then deferencing.
int py2[2][2] = {10,11,12,13}; int* sptr = &py2[0][0]; int** dptr = &sptr; printf("\nAtlast:%d\n",**dptr); *dptr+=1; *dptr+=2; printf("\nAtlast:%d\n",**dptr);:beer:
-
As you know pointers & arrays both move consecutive. Then how come it be totally different? To some extent I can agree. Because the next pointer in the **ptr can be made to point to some other *p pointing somewhere. But here that's not the case.. it's array, quite consecutive and we are making our **ptr point to it. What do you think about the below approach ? getting the address of the first row pointer & getting the address of it and then deferencing.
int py2[2][2] = {10,11,12,13}; int* sptr = &py2[0][0]; int** dptr = &sptr; printf("\nAtlast:%d\n",**dptr); *dptr+=1; *dptr+=2; printf("\nAtlast:%d\n",**dptr);:beer:
It seems you're confusing two well distinct concepts (don't worry: it takes about three years to me to get away from that confusion...). Let's reconsider your points:
Smith# wrote:
As you know pointers & arrays both move consecutive
No. Pointers "move" (in th sense they can receive another address as their own stored value). Array just "are". Array indexes "move" (in the sense they can be used to indicate other array cells).
Smith# wrote:
how come it be totally different
Because they ARE totally different. They simple have a "similar" external interface (same operators).If you don't get this point may be I was not able to explain the first point, but until you don't get it you cannot move away from your trivia. So loop over and over until you get it, find other sources than me (if you find my way to explain is not clear) but there is no way to move over until this crucial point is clear.
Smith# wrote:
Because the next pointer in the **ptr can be made to point to some other *p pointing somewhere. But here that's not the case.. it's array,
You know, but compiler doesn't.
int**for the compiler is just 4 bytes of memory containing the address of an int* that is another 4 byte of memory, somewhere else, containing the address of an int. Whatever you think about this is irrelevant to the compiler.int[]is a consecutive bounce of integers at some place in memory. This place has an address. When you doint a[2] = { 0,1 };
int* pa = a;you assign the address of the array head to the pointer. When you do
*pa = 5;
the compiler assign
5to the memory whose address is stored in "pa". This accidentally is a[0] (but it is not something the compiler is aware of). When you dopa[1] = 6;
the compiler assign 6 to the memory whose address is given by
pa+1*sizeof(int), that accidentally is a[1] (again you know, not the compiler: there is nothing in "pa" that makes the compiler aware of the fact that it is NOW pointing to an array and sometime later on to an individual integer and some later on to an integer inside a class or struct. The design of the [] operator appllied to poitner or to array makes this operation giving a same result just because for monidimensional array, the same calculation is done. Bidimensional arra -
As you know pointers & arrays both move consecutive. Then how come it be totally different? To some extent I can agree. Because the next pointer in the **ptr can be made to point to some other *p pointing somewhere. But here that's not the case.. it's array, quite consecutive and we are making our **ptr point to it. What do you think about the below approach ? getting the address of the first row pointer & getting the address of it and then deferencing.
int py2[2][2] = {10,11,12,13}; int* sptr = &py2[0][0]; int** dptr = &sptr; printf("\nAtlast:%d\n",**dptr); *dptr+=1; *dptr+=2; printf("\nAtlast:%d\n",**dptr);:beer:
Now, let's move a little bit on: If you agree with my previous post, consider this:
int a [2][2] = { 1,2,3,4 };
int[2]* ppa = a;Do you get it? Instead of int**, I use int[2]*: a "pointer to an array of two integers". considering the int[][] as "array of 2 arrays of two integers". The type of int** is int* (that doesn't exist in memory since we store arrays), but the value of int[2]* is int[2] that's just one row of the matrix ( in our case
{{1,2},{3,4}}Now ppa[1][1] is "take the address stored in ppa, add 1*sizeof(int[2]). This is the int[2] representing the second row. Now we're anymore dealing with a pointer, but with an array, whose cell "1" has the value "4".2 bugs found. > recompile ... 65534 bugs found. :doh:
-
It seems you're confusing two well distinct concepts (don't worry: it takes about three years to me to get away from that confusion...). Let's reconsider your points:
Smith# wrote:
As you know pointers & arrays both move consecutive
No. Pointers "move" (in th sense they can receive another address as their own stored value). Array just "are". Array indexes "move" (in the sense they can be used to indicate other array cells).
Smith# wrote:
how come it be totally different
Because they ARE totally different. They simple have a "similar" external interface (same operators).If you don't get this point may be I was not able to explain the first point, but until you don't get it you cannot move away from your trivia. So loop over and over until you get it, find other sources than me (if you find my way to explain is not clear) but there is no way to move over until this crucial point is clear.
Smith# wrote:
Because the next pointer in the **ptr can be made to point to some other *p pointing somewhere. But here that's not the case.. it's array,
You know, but compiler doesn't.
int**for the compiler is just 4 bytes of memory containing the address of an int* that is another 4 byte of memory, somewhere else, containing the address of an int. Whatever you think about this is irrelevant to the compiler.int[]is a consecutive bounce of integers at some place in memory. This place has an address. When you doint a[2] = { 0,1 };
int* pa = a;you assign the address of the array head to the pointer. When you do
*pa = 5;
the compiler assign
5to the memory whose address is stored in "pa". This accidentally is a[0] (but it is not something the compiler is aware of). When you dopa[1] = 6;
the compiler assign 6 to the memory whose address is given by
pa+1*sizeof(int), that accidentally is a[1] (again you know, not the compiler: there is nothing in "pa" that makes the compiler aware of the fact that it is NOW pointing to an array and sometime later on to an individual integer and some later on to an integer inside a class or struct. The design of the [] operator appllied to poitner or to array makes this operation giving a same result just because for monidimensional array, the same calculation is done. Bidimensional arra