Re: Problem with array objects
On 2011-04-09, Paul <pchristor@yahoo.co.uk> wrote:
"A. Bolmarcich" <aggedor@earl-grey.cloud9.net> wrote in message
news:slrniq18hf.2uti.aggedor@earl-grey.cloud9.net...
On 2011-04-08, Paul <pchristor@yahoo.co.uk> wrote:
[snip]
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.
Are you a complete fucking idiot? !!!
No, I'm not that.
"1.7 The C+ + object model [intro.object]
1 The constructs in a C + + program create, destroy, refer to, access, and
manipulate objects. An object is a
region of storage. An object is created by a definition (3.1), by a
newexpression
(5.3.4) or by the implementation
(12.2) when needed. The properties of an object are determined when the
object is created. An
object can have a name (3). An object has a storage duration (3.7) which
influences its lifetime (3.8). An
object has a type (3.9). The term object type refers to the type with which
the object is created. Some
objects are polymorphic (10.3); the implementation generates information
associated with each such object
that makes it possible to determine that object's type during program
execution. For other objects, the
interpretation of the values found therein is determined by the type of the
expressions (5) used to access
them"
*****The term object type refers to the type with which the object is
created. **** PERIOD
Its talking about fucking objects, NOT fucking only polymorphic objects, you
dumb fucking twat.
No, I'm not that, either.
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.
In C++ an objects' type is NOT determined by a pointer that points to it.
You were fucking wrong , you ARE fucking wrong and you cannot accept that
you fucking twat.
No, I'm not that, either.
The quote you gave above from the C++ Object Model includes the
following sentences.
Some objects are polymorphic (10.3); the implementation generates
information associated with each such object that makes it possible
to determine that object's type during program execution. For
other objects, the interpretation of the values found therein is
determined by the type of the expressions (5) used to access them
With a value of a non-polymorphic type, such as an array, the
standard states: the interpretaion of the values is determined by
the type of the expressions used to access type value. In other
words, for a pointer to a non-polymorphic type, the pointer type
determines the type of the result of dereferencing the pointer.
Here is a program that outputs whether the typeid of a dereferenced
pointer and the typeid of what it points to are the same for a
polymorphic object and for an array.
#include <iostream>
#include <typeinfo>
struct Base {virtual void foo() {}};
struct Derived : public Base {};
static void outputWhetherSame(const std::type_info& ti1, const char* n1,
const std::type_info& ti2, const char* n2) {
const char *relStr = (ti1 == ti2) ? "==" : "!=";
std::cout<<"typeid("<<n1<<")"<<relStr<<"typeid("<<n2<<")"<<
" ("<<ti1.name()<<relStr<<ti2.name()<<")"<<std::endl;
}
int main() {
Derived d;
Base* pb = &d;
int a1i[5], *pi = a1i;
outputWhetherSame(typeid(*pb), "*pb", typeid(d), "d");
outputWhetherSame(typeid(*pi), "*pi", typeid(a1i), "a1i");
}
The output that I get is that the typeids are the same for a
polymorphic object, but not for an array. Given the declaration
int a1i[5], *pi = a1i;
pi does not point to an array; pi points to an int.
What I am is someone who accepts exactly what is in the standard.
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
So you were wrong, once again you were speaking utter bullshit.
Let me see if I have this right. it is utter bullshit that a pointer
variable does not point to anything value until the value is set?
This is not the first time that you have omitted words or sentences
from what I have written and used what remained out of context.
Here are the lines that you omitted at this point.
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.
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++.
In C++ a null pointer IS a valid object. I don't give a fuck what you think
about dereferncing it.
In this sequence of followups:
- I wrote: "Dereferencing the null pointer is undefined behaviour."
- You replied: "A null pointer is a valid object and well defined in
the C++ standards."
- I replied with a paragraph from the C++ standard that gave
dereferencing of the null pointer as an example of an undefined
operation.
If you don't care what the effect of dereferencing the null pointer
is, why did you followup about it?
[snip]