Re: Problem with array objects
On 2011-04-08, Paul <pchristor@yahoo.co.uk> wrote:
"A. Bolmarcich" <aggedor@earl-grey.cloud9.net> wrote in message
news:slrnipui24.1tih.aggedor@earl-grey.cloud9.net...
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 quote wasn't posted because it mentioned polymorphic types, it was
posted becuase it says:
"The term object type refers to the type with which the object is created."
When reading a quote from a programming language standard, it is a
good idea to read the whole quote, including parts that establishes
the context in which the quote applies. In this case the context
is polymorphic objects.
An objects' type is defined when its created, it is not defined by some
pointer that points to it.
You said :
"In C++ what a pointer points to depends on the pointer type."
This is complete nonsense because a pointed to object is not defined by a
type of pointer, pointing to it.
The type of pointer determines the type of value obtained when the
pointer is dereferenced, the change in the pointer value when it
is incremented, and the non-virtual member of a polymorphic object
that is accessed.
[snip]
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.
No it declares a pointer of type poiner to array. It doesn't point to
anything valid until its been initialised.
Dereferencing
that pointer results in an array of 3 int.
Dereferencing it results in UB.
That's right, a pointer variable does not point to anything valid
until its value is set. Given the declaration
int a3i[3], (*p3i)[3] = &a3i;
that sets the value of p3i and the value obtained by deferencing p3i
is defined. With that initialization, evaluating (*p3i) and a3i
result in the same value.
[snip]
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.
A null pointer is a valid object and well defined in the C++ standards.
Here is paragraph 4 of section 1.9 (Program execution) of the C++
standard.
Certain other operations are described in this International
Standard as undefined (for example, the effect of dereferencing
the null pointer). [Note: this International Standard imposes no
requirements on the behavior of programs that contain undefined
behavior. ]
If you think that dereferencing the null pointer is defined, you
are thinking of a programming language other than C++.
[snip]
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?
Read the section titled: Arrays.
I have read that section. If you think that is states 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, please cite or post the the specific
paragraph(s).
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.
You said :
"The output "int[5]" demonstrates that pali is a pointer to a 1-dimensional
array."
Its not a pointer, which you still repeat in your correction, it's an
array.
Given the delcaration
int i, *ip, a1i[5], (*pa1i)[5] = &a1i;
- The output "int" for typeid(i).name() indicates that i is an int.
- The output "int" for typeid(*ip).name() indicates that *ip is an
int. Something that when deferenced is an int is a pointer to
an int.
- The output "int[5]" for typeid(a1i).name() indicates that a1i is a
1-dimensional array.
- The output "int[5]" for typeid(*pa1i).name() indicates that *pa1i
is a 1-dimensional array. Something that when dereferenced is
a 1-dimensional array is a pointer to a 1-dimensional array.
You appear to be thinking about a programming language other than C++.
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
BS also said that a pointer of type char* can point to a single char or an
array of chars.
You think a char* cannot possibly point to an array of chars, which is a
direct disagreement with BS.
The context in which he said pointer of type char* can point to an
array of chars was C-style strings. He did not go into the details
that the name of an array containing a C-style string was implicitly
converted to a pointer to the first character of the array. At
other times he has gone into that detail, such as the above example
and the example that followed it in "The C++ Programming Language".
Part of the following example was:
char v[] = "Annemarie";
char* p = v; // implicit conversion of char[] to char*
Where has he said that that a pointer of type int* can point to an
array of int, as opposed to can point to the first element of an
array of int?
I agree with all BS has said in your quote , it does not in any way suggest
what you are suggesting.
It suggests exactly what I have been saying. In the first example
p1 points to an element of an array; it does not point to the array.
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.
I can tell you without even compiling this I won't get the same output you
get.
*pa1i will give me ... int[5]
pa1i will give me .... int (*)[5]
You don't get the exact same output because as I wrote above, the
C-style string "value returned by type_info::name() is implementation
defined". We are using different C++ compilers.
What do you tihnk this proves? It outputs the pointer-TYPE. The pointer
doesn't even point to anything valid, its uninitialised.
It proves what I have been saying: *pa1i is an array and pa1i is a
pointer to an array. You are the one who introduced what
typeid(*pa1i).name() returns. I am simplying using what it returns
to support what I claim.
This type of pointer can point to a 2d array or a 1d array but its more
general use is a pointer to a 2d array. Yes its type is pointer to 1d array,
because thats how pointers to arrays work in C++, see the section on arrays
which explains why an array is pointed to by a (n-1) dimensional type
pointer.
An int* is a pointer to an int. Given what you mean by "point to",
as opposed to what it means in C++, an int* could point to an array
of any number of dimensions. For example, given
int a4i[1][2][3][4], *ip = &(a4i[0][0][0][0]);
the value of the pointer to int ip is an address is the address of the
4-dimensional array a4i, therefore a pointer to int is pointing to a
4-dimensional array.
Why can't you just accept what is in the standards instead of being ignorant
to this? It's not irelevant as you have previously said.
I accept what is actually written in the C++ standard. You are the one
who is interpreting beyond what is actually written.
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()
So if you accept what is written in the C++ standards then, when
dereferenced, a pointer to an array returns a pointed to (n-1) dim array.
If pa1i is derefernced it reutrns a 1d array, so the pointed to array is a
2d array.
(2-1) = 1d array.
If you do not accept this I cannot say anymore, its how the C++ language
works and its written in the C++ standards.
Your logic here is
- deferencing a pointer to a 1d array results in a 1d array
- a 2d array in a context where array-to-pointer conversion is done
results in a 1d array
- therefore a pointer to a 1d array points to a 2d array
However, the conclusion is wrong in general because it does not hold
in contexts where array-to-pointer conversion is not done.
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).
No if it pointed to a 1d array then (1-1) = 0 .
Why would a pointer to a 1d array, as opposed to a 1d array, undergo
a conversion to a pointer to an array of 1 fewer dimensions?
Additionally why is it possible to do :
int (*p)[5] = new int[S][5];
or
int arr[5][5] = {0};
p=arr;
In the first declaration, "new int[S][5]" returns a pointer to an
int[5] and the pointer variable p is set to that return value.
Initializing a variable of type pointer to int[5] with a value of
the same type is allowed in C++.
In the assignment statement, "arr" evaluates to a pointer to an
int[5] (array-to-pointer conversion is done on an int[5][5],
resulting in a pointer to an int[5]). Assigning to a variable of
type pointer to int[5] a value of the same type is allowed in C++.
As a result of the assignment, the variable points to the first element
(an array of 5 int) of the variable named arr (an array of 5 arrays of
5 int).
C++ fully supports that this TYPE of pointer can be used to point to 2d
array.
Yes it can also be used to point to a 1d array but its more commonly used to
point to a 2d array
If you refuse to think of pointers to arrays as being generally (n-1) dim
than the pointed to array, then thats up to you. Please dont try to say
everyone who accepts this is wrong becuase a pointer type can only point to
an object of that type, that is simply incorrect.
In C++ a pointer to a 1d array can point to a 1d array. That 1d array
may be an element of a 2d array. However, such a pointer points to
a 1d array, not a 2d array. Believing that it points to a 2d array can
lead to errors similar to those using the external declaration
int *pa;
and defintion
int pa[5]
in different files because arrays and pointers are the same.
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.
And?
I don't know why you keep going on.
Accept what BS says, accept what the C++ standard says. Don't be like those
idiots around here who only argue because they are total arseholes who
cannot accept when they make mistakes.
I accept exactly what the C++ standard says; I don't interpret it in
a way that can lead to confusion.
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 array element is a single object, not a sub-array.
In C++ a multidimensonal array is an array of arrays. Given the
declaration
int a2i[3][5];
a2i is an array of 3 elements where each of those elements is an
array of 5 int. That is what paragragh 7 of section 8.3.4 (Arrays)
of the standard indicates. Here it is (again)
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.
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.
Ok you carry on ignoring the C++ standards and Bjarne Stroustrup and many
other experts in the field. Thats your problem not mine, if you think you
are ever going to make me think you are correct and all these other good
sources of knowledge are total bullshit then you are mistaken.
I accept exactly what is written in the C++ standard. I realize
what I or others write will not change your mind. You have reached
certain conculsions that you hold to be correct regardless of what
is exactly written in the C++ standard.
Readers of this newsgroup should see exactly what is written in the
C++ standard. That is why I have included complete paragraphs from
it in my posts.