Re: Problem with array objects
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.
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.
[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
(*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.
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.