[defns.dynamic.type] The note is misleading

[xmh0511]

Full name of submitter (unless configured in github; will be published with the issue): Jim X

If a pointer p whose static type is “pointer to class B” is pointing to an object of class D, derived from B, the dynamic type of the expression *p is “D”. References are treated similarly.

Since the pointer p already points to the subobject B, how does it simultaneously point to the containing object? The intent should be:

If a pointer p whose static type is “pointer to class B” points to an object that is a base class subobject of an object of class D derived from B, the dynamic type of the expression *p is D. References are treated similarly.

[languagelawyer]

Since the pointer p already points to the subobject B

It does not.

points to an object that is a subobject of an object of class D derived from B, the dynamic type of the expression *p is D

In this case, the dynamic type would be the type of the subobject.

[xmh0511]

In this case, the dynamic type would be the type of the subobject.

The definition of dynamic type is

type of the most derived object to which the glvalue refers

The most derived object is:

If a complete object, a member subobject, or an array element is of class type, its type is considered the most derived class, to distinguish it from the class type of any base class subobject; an object of a most derived class type or of a non-class type is called a most derived object.

So, when p points to a base class subobject, the most derived object of the object pointed to by p is the complete object.

[jensmaurer]

The only problem I'm seeing here is that "dynamic type" refers to the most-derived object, so in the scenario above, if there is another class E derived from D, the statement would be false (p possibly points to D, yet the dynamic type is E).

But the discussion above doesn't mention that possibility, so I'm lost.

[lprv]

I think the point here is that having a B* pointing to a D is rather unusual, as obtaining one requires a reinterpret_cast, because the implicit derived-to-base conversion yields a pointer to the base class subobject. The note may mislead readers into thinking otherwise, and would likely be more useful if it dealt with the more common scenario.

(Not sure why this wasn't opened as an editorial issue.)

[xmh0511]

I think the point here is that having a B* pointing to a D is rather unusual, as obtaining one requires a reinterpret_cast, because the implicit derived-to-base conversion yields a pointer to the base class subobject.

Yes, the only possibility that we point to an object of a derived class type with a pointer value of type "pointer to base class type" is reinterpret_cast<B*>(ptr_d_obj);, indirection such a pointer can result in UB per [expr.pre] p4

If during the evaluation of an expression, the result is not mathematically defined or not in the range of representable values for its type, the behavior is undefined.

Although this wording is unclear whether the value of the Derived class type is out of the range of representable values for the bass class.

[frederick-vs-ja]

(Not sure why this wasn't opened as an editorial issue.)

I think we should continue in cplusplus/draft#5762.

[tkoeppe]

Closing this, since it only affects an example and is thus editorial.