Re: Problem with array objects
"A. Bolmarcich" <aggedor@earl-grey.cloud9.net> wrote in message
news:slrnir64sj.pso.aggedor@earl-grey.cloud9.net...
On 2011-04-20, Paul <pchristor@yahoo.co.uk> wrote:
"A. Bolmarcich" <aggedor@earl-grey.cloud9.net> wrote in message
news:slrniqrm4f.2usb.aggedor@earl-grey.cloud9.net...
[snip]
A pointer to an array of 4 ints, when dereferenced, returns an array
of 4 ints. Look at the output of running the following program.
#include <iostream>
#include <typeinfo>
int main() {
int a1i[4], (*pa1i)[4] = &a1i;
std::cout<<"typeid( a1i)="<<typeid(a1i).name()<<std::endl;
std::cout<<"typeid(*pa1i)="<<typeid(*pa1i).name()<<std::endl;
}
You are dereferencing an array-type , not an array.
For example:
int arr[40] ={0};
int* parr = arr;
int (*pparr)[40] = &arr;
std::cout<< "address of arr[0]:\t" << &arr[0] <<std::endl;
std::cout<< "value of *parr:\t\t" << *parr <<std::endl;
std::cout<< "value of *pparr\t\t" << *pparr <<std::endl;
Dereferencing pparr does not access the array it accesses a temporary
pointer.
The pointer pparr does not reference the array, it references an
array-type
object.
Dereferencing pparr accesses an array in the same sense that using
the name arr accesses an array.
No it doesn't
*arr =1; /*Accesses the array*/
*pparr=1; /*Cannot do this*/
In the above statement, *pparr dereferences a pointer to an array,
resulting in an array to which array-to-pointer conversion is applied,
resulting in a pointer to the first element of the array.
The expression &arr[0] also results in a pointer to the first element
of the array. Due to value to which pparr was initialized, the output
to cout of the expressions *pparr and &arr[0] are the same. The
output to cout of the expression arr would also be the same, due to an
implicit array-to-pointer conversion.
The expression *parr dereferences a pointer to int, resulting in the
pointed to int. That same int would be output by the statement
std::cout<< "value of (*pparr)[0]\t\t" << (*pparr)[0] <<std::endl;
or
std::cout<< "value of arr[0]\t\t" << arr[0] <<std::endl;
Look at the difference in the output of the two statements:
std::cout<< "value of pparr\t" << pparr <<std::endl;
std::cout<< "value of pparr+1\t" << pparr+1 <<std::endl;
On a system where sizeof int is 4 the difference will be 0xa0
(decimal 160). That is the amount of space occupied by an
array of 40 ints. pparr is a pointer to an array of 40 ints.
The variable parr is a pointer to an int, not a pointer to an array.
The variable pparr is a pointer to an array, not a pointer to a
pointer to an array.
The (implementation defined) values returned by typeid(a1i).name()
and typeid(*pa1i).name() are the same. The output indicates that
both ai1 and *pai1 are arrays of 4 ints.
No it outputs the type, not the pointed to object.
*pa1i does not derefernece a pointer to the array, it dereferenes a
pointer
to a tempory object of array-type.
Basically its a fancy pointer to a pointer.
I never said that typeid outputs the pointed to object. The
declaration was
int a1i[4], (*pa1i)[4] = &a1i;
pa1i is a pointer to an array. *pa1i dereferences it resulting in
an array. The only objects here are an array (named a1i) and a
pointer to array (named pa1i). There is no pointer to a temporary
object here.
No there are four integer objects here, that you fail to acknowledge.
[snip]
The fact that the result of incrementing p is a pointer to the next
int address indicates that p is a pointer to an int, not a pointer
to an array of 4 ints.
No this is incorrect a pointer of type int* can point to both a single
int
and an array of ints.
If an int* could point to an array of int, the following statement
that tries to initialize an int* with a pointer to an array of int
would be allowed, but it isn't.
int a1i[4], *pi = &a1i;
Correction: the line
int a1i[4], *pi = &a1i;
should have been
int a1i[4], *(pa1i)[4] = &a1i;
&ali is a pointer derivation from an array-type.
This creates a pointer that references an array-type, not the actual
array
of ints.
To reference an array of ints, you need to use a pointer-type int*, and
you
do not use the addressof& operator, like so:
int* p = a1i;
This pointer , when dereferenced, accesses the array like so:
p[int_offset];
The expression &a1i is a pointer to the array named a1i (just as the
expression &i where i is an int is a pointer to the int named i).
Dereferencing &a1i results in the array of int named a1i.
The expression p[int_offset], where p is a pointer to an int, treats
p as if it is a pointer to an element of an array of ints. The
result of the subscript operation is the int that is int_offset
elements away from the array element pointed to by p.
The following pointer-type
int (*p)[4] =&a1i;
Does not access the array when dereferenced, it accesses an array-type
object. This object is bascially another pointer to the array.
Pointing to an array-type object, is not the same as pointing to the
array
of ints. It points to AN array , yes an array-type object( which is
basically another pointer under the hood), it doesn't point to THE array
of
ints.
Here, the object named p is a pointer to the array named a1i.
Dereferencing it results that array. The expression
No it doesn't , dererencing this pointer results in a non modifiable object
that cannot be used to access the array unless converted.
So it results in something that can be converted to a pointer to the array.
(*p)[int_offset]
access the int_offset element of that array.
Look at the output of the following program.
#include <iostream>
#include <typeinfo>
int main() {
int a1i[4], (*pa1i)[4]=&a1i;
std::cout<<"typeid(a1i)"<<((typeid(a1i)==typeid(*pa1i))?"==":"!=")<<
"typeid(*pa1i)"<<std::endl;
std::cout<<"a1i"<<((a1i==*pa1i)?"==":"!=")<<"*pa1i"<<std::endl;
}
a1i and *pa1i have the same type and value. pa1i points to the
array of int named a1i.
In the declaration
int a2i[3][4], (*p1i)[4] = a2i;
p1i is a pointer to an array of 4 ints.
But when its dereferenced in doesn't return 4 ints. It is not a pointer
to
an array(entity) of 4 ints, it is a pointer to array-type.
What derefencing p1i retuns is an array of 4 ints. You omitted the
word "array" from what I wrote.
When you dereference p1i, you create a temporary array-type object the
value
of which is another memory address. You do not get an array of 4 ints,
example:
int arr[4] = {1,2,3,4};
int (*p)[4] = &arr;
std::cout<< *p;
The type of p is an array-type, this means it points to an object of
array-type, not an array of int objects.
There is no temporary array-type object the value of which is
another memory address. There are two objects: an array named arr
and a pointer to array named p. Due to the initialization, p points
the array of int named arr.
Again you fail to acknoweldge the four integer objects.
Where is this object that you describe as "the array named arr" strored?
Evaluating the expression *p results in an array, the one named
arr; array-to-pointer conversion is applied to that array resulting
in a pointer to the first element of the array, a pointer to int.
That pointer to int is converted to a pointer to void to call the
operator<<(const void*) of cout.
[snip]
According to the C++ standard an n-dimensional array is converted to
a pointer to an (n - 1)-dimensional array. The result of that
conversion on a 2d array is a pointer to 1d array. A pointer to a
1d array points to a 1d array, not to a 2d array. You appear to be
confusing C++ with a programming language in which arrays are
polymorphic over dimensions.
You are confusing the whole context of the statement in the standard.
It doesn't mean the array is converted to a pointer that no longer points
to
the array.
I'm not confusing anything. I accept what the C++ standard states.
Here, it states that a conversion is done from an array to a pointer
to an element of the array. What is pointed to is an element of the
array, not the array.
You must be pointing to the array , to point to an element. Where is this
element stored if not witihin the array?