Re: Problem with array objects
On 2011-04-07, Paul <pchristor@yahoo.co.uk> wrote:
"A. Bolmarcich" <aggedor@earl-grey.cloud9.net> wrote in message
news:slrniprt2j.kbq.aggedor@earl-grey.cloud9.net...
On 2011-04-06, Paul <pchristor@yahoo.co.uk> wrote:
"A. Bolmarcich" <aggedor@earl-grey.cloud9.net> wrote in message
news:slrnippgqs.2q59.aggedor@earl-grey.cloud9.net...
[snip]
In C++ what a pointer points to depends on the pointer type. Here
is paragraph 1 of section 5.3.1 of the C++ standard:
No, a pointer type doesn't define what is pointed to.
1.7 The C++ Object Model states:
"The term object type refers to the type with which the object is created.
Some
objects are polymorphic".
Although some objects are polymorphic, this discussion has been
about arrays. Arrays are not polymorphic; an array type does not
inherit from another type. The element type of an array may be
polymorphic, but an array is not.
The pointer type of a pointer that points to an object in C++ can be a void*
or another type of pointer that is not the same type as the object. You are
misinterpreting the C++ standards.
I'm not misinterpreting the C++ standard. What a pointer may validly
point to is a detail not previously covered in these posts. These
posts are long enough without adding more details. However, since it
appears you want to discuss these details, I'll oblige.
Attempts to access what is pointed may be undefined depending on
whether the pointer type (the static type) and the object type
(the dymanic type) is a valid combination. When T is a
non-polymorphic type, dereferencing a pointer to T attempts to
access an object of type T. When T is a polymorphic type,
dereferencing a pointer to type T attempts to access an object of
type T except when a virtual function is called on the object.
A void* may validly point to any object, but a void* cannot be used to
access what it points to.
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.]
This is a paragraph that explains the unary operator *.
It explains how dereferencing works, not what a pointer can or cannot point
to.
According to the standard: "If the type of the expression is a pointer
to T, the type of the result is T." The result of dereferencing a
valid pointer is what the pointer points to.
I don't have any serious intellectual problems. I am using the term
"points to" with the meaning it has in C++. The meaning of the term
may be different in other contexts, but using another meaning when
discussing C++ may lead to errors.
"Points to" is a term that quite clearly needs no definition in the C++
standard.
The C++ standard state the following;
4.10 Pointer conversions:
"An rvalue of type "pointer to cv T," where T is an object type, can be
converted to an rvalue of type
"pointer to cv void." The result of converting a "pointer to cv T" to a
"pointer to cv void" points to the
start of the storage location where the object of type T resides, as if the
object is a most derived object (1.7)
of type T (that is, not a base class subobject)."
As you can see with a pointer to an object, the pointer actually points to
the start of the objects storage location. So do you think a pointer to an
object doesn't actually point to an object?
No, I don't think that; a pointer to an object points to an object.
In C++, pointers have a type in addition to a storage location value.
The result of dereferencing a pointer is what the pointer points to.
The "most derived object" wording applies to an object with a polymorphic
type; an array is not polymorphic.
According to the C++ standard, "int (*p3i)[3]" declares a "pointer
to an array of 3 int".
Its TYPE is pointer to array. What it points to can be null, or almost
anything.
You are obviously confusing its type with what it points to.
"int (*p3i)[3]" declares pointer to an array of 3 int. Dereferencing
that pointer results in an array of 3 int. The type that was used
when the object allocated does not matter except in a a call to a
virtual function. Dereferencing a pointer that is not pointing to an
object of the right type is undefined behavior.
That array has one dimension.
No it doesn't the standard clearly says that is a TYPE. The standard does
not define that it points to a 1d array. The standard actually implies
that
type points to a 2d array, in the section about pointers to arrays..
See the above quote from section 5.3.1 of the C++ standard about the
unary * operator, which contains: "If the type of the expression is
a pointer to T, the type of the result is T." A pointer to a 1d
array points to a 1d array. If a pointer to a 1d array could point
to a 2d array, the statement
The above is describing the result of dereferencing a pointer of type T.
This does not define what a pointer points to , a pointer can be null and
point to nothing.
Dereferencing the null pointer is undefined behaviour. The result of
dereferencing a valid pointer to T is a value of type T.
int a2i[3][5], (*pa1i)[5] = &a2i;
would be allowed, but it isn't.
Exactly where (section and paragraph) does the standard state that a
pointer to a 1d array can point to a 2d array, as opposed to can point
to a 1d element of a 2d array?
This is another example of your bad coding, you dont take the address of an
array to get a pointer to it.
The result of the unary & operator is a pointer to its operand. Taking
the address of an array is how you get a pointer to the array. Look at
the return value of typeid(&a2i).name().
You have not answered the question: Exactly where (section and
paragraph) does the standard state that a pointer to a 1d array
can point to a 2d array, as opposed to can point to a 1d element
of a 2d array?
[snip]
std::cout << typeid(*pa1i).name ;
outputs int[5]. There is no implicit conversion to pointer unless it's
further dereferenced i.e: pali[0][0].
There is no implicit conversion in a typeid expression. According
to paragraph 3 of section 5.2.8 (Type identification) of the C++
standard:
When typeid is applied to an expression other than an lvalue of
a polymorphic class type, the result refers to a type_info object
representing the static type of the expression. Lvalue-to-rvalue
(4.1), array-to-pointer (4.2), and function-to-pointer (4.3)
conversions are not applied to the expression. If the type of
the expression is a class type, the class shall be
completely-defined. The expression is not evaluated.
The output "int[5]" demonstrates that pali is a pointer to a
1-dimensional
array. In a context where the expression *pa1i is evaluated, the
resulting
1-dimensional array undergoes array-to-pointer conversion, resulting in
a
pointer to int.
The output demonstrates its an array , not a pointer.
The type int[5] is not a pointer. As I said this is not implicitly
converted
to a pointer until its further dereferenced. And when it is converted to
a
pointer it will be pointer-type: int*, not int (*)[5].
That's right, *pai1i is an array.
So why did you say it was a pointer? Its not a pointer its an array.
What I said (correcting for typos) was: pa1i is a pointer to an array,
*pa1i is an array, and when *pa1i (an array of int) is in a context
where array-to-pointer conversion is done, it is implicitly converted
to a pointer to int. That pointer to int points to the first element
of the array.
Here is what Bjarne Stroustrup wrote in The C++ Programming
Language (page 91 of the Special Edition)
The name of an array can be used as a pointer to its initial
element. For example:
int v[] = { 1, 2, 3, 4 };
int* p1 = v; // pointer to initial element (implicitly converted)
int* p2 = &v[0]; // pointer to initial element
int* p3 = &v[4]; // pointer to one beyond last element
The value of "typeid(pa1i).name()"
would indicate that pa1i is a pointer to int[5] (the value
returned by type_info::name() is implementation defined).
No its an array , it not a fucking pointer at all it's an array.
What output do you get for the following program?
#include <iostream>
#include <typeinfo>
int main() {
int (*pa1i)[5];
std::cout<<"typeid(*pa1i)="<<typeid(*pa1i).name()<<std::endl;
std::cout<<"typeid( pa1i)="<<typeid( pa1i).name()<<std::endl;
}
The output I get is
typeid(*pa1i)=A5_i
typeid( pa1i)=PA5_i
The output indicates that *pa1i is an array of 5 int and pa1i is a pointer
to an array of 5 int.
The
type int[5] is not a pointer type. However, when used in a context
where array-to-pointer conversion is applied, a value of type int[5]
is implicitly converted to a pointer to int.
Your last 3 statements said it's a poiinter now you say its not a pointer,
you can't accept that *pa1i returns an array because it proves the standards
confirms it is a pointer to a a 2d array.
What I said was that *pa1i is an array and pali is a pointer to an
array. The result of the expression
typeid(*pa1i).name()
indicates that *pa1i is a 1d array of int; array-to-pointer
conversion is not applied to the operand of typeid (see the above
quote from the Type Identification section of the standard).
In the statement
int *pi = *pa1i;
*pa1i is a 1d array of int to which array-to-pointer conversion
is applied, resulting in a pointer to int. Here is part of
paragraph 14 of section 8.5 (Initializers):
Otherwise, the initial value of the object being initialized is
the (possibly converted) value of the initializer expression.
Standard conversions (clause 4) will be used, if necessary, to
convert the initializer expression to the cv-unqualified
version of the destination type; no user-defined conversions
are considered.
It is initialised to point to a 2d array, with:
int a2i[3][5], (*pa1i)[5] = a2i;
a2i is a 2d array , not a 1d array.
An array is defined at allocation, not by a pointer that points to it.
Although a2i is a 2d array, when used in the initialization
expression array-to-pointer conversion is applied to it, and the
result is a pointer to the 1d array that is the first element of a2i.
The variable pa1i (a pointer to a 1d array) is initialized to that
pointer to a 1d array result.
The pointed to array is a 2d array, not a 1d array. The pointer type is
pointer to int[5], which does not point to an element, it points to a 2d
array. The reason its type is pointer to 1d array is because of the rules
of the C++ language, the standards state:
When dereferenced a pointer ot an array returns the pointed to (n-1)
dimensional array.
You are partially right. The type of the initialization expression
a2i is a pointer to int[5]. However, you are wrong about it not
pointing to an element; it points to the first of the 3 int[5]
elements of the array named a2i. Here is paragraph 1 of section 4.2
(Array-to-pointer conversion) of the C++ standard:
An lvalue or rvalue of type array of N T or array of unknown bound
of T can be converted to an rvalue of type pointer to T. The result
is a pointer to the first element of the array.
The pointed to array is a 1d array because accessing what a pointer
to a 1d array points to accesses a 1d array. In this case, the 1d
array is an element of a 2d array.