Re: Problem with array objects
On 2011-04-18, Paul <pchristor@yahoo.co.uk> wrote:
"A. Bolmarcich" <aggedor@earl-grey.cloud9.net> wrote in message
news:slrniqou48.1pof.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;
}
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.
[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;
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 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.
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.
[snip]
So according to you this is incorrect:
"The pointer declaration char *p, on the other hand, requests a place
which
holds a pointer, to be known by the name ``p''. This pointer can point
almost anywhere: to any char, or to any contiguous array of chars, or
nowhere "
Im sorry but I agree with the above quotation , and if you disagree then
I
diasagree with you and I think it is more likely that you are incorrect
than
the source of this quotation.
I don't disagree that a char* can point almost anywhere. However,
no matter where it points, an operation on a char* treats what the
char* points to as a char.
But you disagree that char* can point to an array? According to you *char
returns only one char and not multiple chars therefore it is incorrect to
say a char* can point to an array of chars. So you must disagree with the
above.
When speaking at the level of detail of the C++ standard, a char*
can point to a char, not to an array of char. A term, such as "point
to" used in the context of a programming language does not necessarily
have the same meaning that it has in other contexts.
You must also disagree with the following:
<quote ref=http://www2.research.att.com/~bs/glossary.html>
"char* - pointer to a char or an array of char."
</quote>
Now since you are in complete disagreement with highly respected authorities
who were probably teaching C++ before you'd even heard of it. Do you not
think that perhaps you're missing something important here?
What I disagree with is taking part of a glossary entry over what is
in the C++ standard. You omitted the remaining sentences of that
glossary entry: "Typically assumed to point to a C-style string.
Prefer a standard library string over a C-style string when you can.
TC++PL 2.3.3, 13.5.2."
The context of the glossary entry is about a C-style string. With a
C-style string the char* points to the first character of a zero
termainate array of characters. The glossary does not have a similar
entry for any other pointer type.
I accept what is in the C++ standard. If words of highly respected
authorities taken out of context disagree with what is in the C++
standard, I take with is in the C++ standard over those words.
char* p= new char[16];
p[3] = '3';
The above treats the char pointer as an array, not as a single char.
p[3] is equivalent to *(p+3). When an int is added to a pointer to
char, the pointer to char behaves as a pointer to an element of an
array of char. An element of an array of char is a char, not an
array of char.