Re: Problem with array objects
"A. Bolmarcich" <aggedor@earl-grey.cloud9.net> wrote in message
news:slrniqrm4f.2usb.aggedor@earl-grey.cloud9.net...
[snip]
What you call pointer-type determines what a C++ pointer points
to. Here is paragraph 1 of section 5.3 of the C++ standard:
The unary * operator performs indirection: the expression to
which it is applied shall be a pointer to an object type, or
a pointer to a function type and the result is an lvalue
referring to the object or function to which the expression
points. If the type of the expression is pointer to T, the
type of the result is T. [Note: a pointer to an incomplete
type (other than cv void ) can be dereferenced. The lvalue thus
obtained can be used in limited ways (to initialize a reference,
for example); this lvalue must not be converted to an rvalue,
see 4.1. ]
I accept exactly what is in the C++ standard. Given the declaration
int *p = new int[4];
p is a pointer to an int and the result of *p is an int. What you
wrote, "p is a pointer to an array of 4 ints", is incorrect; the
result of *p is not an array of 4 ints..
No p is a pointer to an array of 4 ints.
When it is dereferenced it returns an int because the pointer-type is
int*,
which complies with this quotation from the standards on dereferencing.
The fact that derefencing it returns an int indicates that it is a
pointer to int. Derefencing a pointer to an array of 4 ints would
return an array of 4 ints.
You cannot get a pointer that, when dereferenced, returns 4 ints. Or 40
ints
or whatever size the array is.
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.
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.
[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;
&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 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.
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.
When an array is converted to a pointer it is converted to a pointer-type
of
an (n-1) dimensionsal array.
That's right for multidimensional arrays. For example, when the
conversion is done on a 2d array the result is a pointer to a 1d
array.
Its the same for 1d arrays, its just a bit silly to say a (1-1)dimension
array, which is a single object.
Incrementing it results in
a pointer to the next array of 4 ints. The subscript operator can
be applied to the result of dereferencing p1i, as the subscript
operator can be applied to any array in C++.
The result of the initialization expression a2i is given in
paragraph 7 of section 8.3.4 of the C++ standard:
A consistent rule is followed for multidimensional arrays. If E
is an n-dimensional array of rank ixjx...xk, then E appearing in
an expression is converted to a pointer to an (n - 1)-dimensional
array with rank jx...xk. If the * operator, either explicitly or
implicitly as a result of subscripting, is applied to this pointer,
the result is the pointed to (n - 1)-dimensional array, which
itself is immediately converted into a pointer.
The above clearly expalins how arrays are converted to pointers in C++.
A 1dim array such as int arr[16], is converted to a pointer type int*.
A 2dim array such as int arr[3][16] is converted to a pointer type int
(*)[16].
I accept exactly what is in the standard. The 2-dimensional array
a2i in the initialization expression is converted to a pointer to a
1-dimensional array. As a result of the initialzation, p1i, a
pointer to a 1-dimensional array, points to that 1-dimensional array.
If a 2d array is converted to a pointer , the pointer points to a 2d
array.
The pointed to TYPE is a 1d array and you are obviously confusing this
with
with the pointed to entity.
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.
Run out of time need to cut this short.
BBFN
..