dynamic_cast does not work as specified

Here's a problem I hit that is inconsistent with the documentation.

I'm handling an OnUpdate notification, where the CObject* can be one of several types
depending on the value of lHint.

So the code is basically

void CMyView::OnUpdate(CView * pSender, LPARAM lHint, CObject *pHint)
   {
    if(lHint == 0 && pHint == NULL)
       { /* normal update */
        CView::OnUpdate(pSender, lHint, pHint);
        return;
       } /* normal update */

    if(lHint == WHATEVER)
       { /* update the whatever */
        SubThing * p = dynamic_cast<SubThing *>pHint;
        ASSERT(p != NULL);
        if(p != NULL)
            DoSomething(p);
       } /* update the whatever */
    } // CMyView::OnUpdate

where I have defined

class Thing { ... };
class SubThing : public Thing { ... };

If I try to single-step into it, it tries to trace a source file along some bizarre path
for rtti.cpp, but this source is not included in the distribution.  Bummer.

So, I thought, it might have to do with the fact that (due to exceptionally poor design
decisions in the original MFC design) the pHint is declared to be a CObject*, unrelated to
a Thing or SubThing (in a rational world, it would have been an LPVOID).  The line

        SubThing * p = dynamic_cast<SubThing *>pHint;

generates the compile-time diagnostic:
        C2681: 'CObject *': invalid expression type for dynamic_cast

I have no idea why this is an invalid expression for dynamic_cast.  But it may deal with
some obscure, undocumented rule.

But dynamic_cast is defined to work on, among other expressions, a pointer-to-void, so I
tried

        LPVOID ptr = (LPVOID)pHint;
        SubThing * p = dynamic_cast<SubThing *>p;

but that produces an error
        C2681: 'LPVOID': invalid expression type for dynamic_cast

in spite of the documetnation of dynamic_cast, which *clearly* states:

        The type-id must be a pointer or a reference to a previously defined class type or
a "pointer to void". 

It turns out I can get around this by doing

        Thing * ptr = (Thing *)pHint;
        SubThing * p = dynamic_cast<SubThing *>ptr;

So does this represent an error in the documentation, or an error in the implementation?
				joe
Joseph M. Newcomer [MVP]
email:  XXXX@XXXXX.COM 
Web:  http://www.**--****.com/ 
MVP Tips:  http://www.**--****.com/ 

You're spot-on about the poor design decisions.

The error message is telling you that pHint (a CObject *) cannot be up- 
or downcast to a SubThing * ... which is correct because neither one 
inherits from the other (and they're not identical).

If you were to make your class Thing inherit from CObject it would 
work.


Yes (though I'd have used "reinterpret_cast<Thing *>"). The Dynamic 
cast is allowed there because SubThing and Thing are related classes.


The implementation seems to conform to the standard (see 5.2.7 "Dynamic 
cast").

Cheers,
 Daniel.
 

On Mon, 12 Jan 2009 04:59:06 -0500, Joseph M. Newcomer




Was that a rimshot I heard in the distance? :)


Indeed, pHint had better be of a type that can be legally converted to
SubThing* via a C-style cast.


If you want to use dynamic_cast, but you're coming from void*, or T* where
T is a lie, as it in your example where MFC makes you use CObject* as a
generic pointer type, you first have to cast the pointer to a known type
that has RTTI information attached, i.e. a type that has a vtbl, i.e a type
that has a virtual function, the latter being the real requirement. That
initial cast cannot be a dynamic cast. Instead, it must be a /valid/
reinterpret_cast. Then you can dynamic_cast the result of the
reinterpret_cast to another type.


It is rather presumptuous.


You can also perform a cross-cast, e.g. cast between X and Y in this MI
hierarchy:

#include <stdio.h>

struct X { virtual void f() {} };
struct Y {};
struct Z : X, Y {};

int main()
{
   Z z;
   X* p = &z;
   Y* q = dynamic_cast<Y*>(p); // q points to z's Y.
   X x;
   X* r = &x;
   Y* s = dynamic_cast<Y*>(r); // s is set to NULL.

   printf("%p, %p, %p\n",
         (void*) static_cast<Y*>(&z),
         (void*) q,
         (void*) s);
}

X>cl -W4 a.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 15.00.30729.01 for
80x86

X>a
0012FF30, 0012FF30, 00000000

That's why I spoke in terms of the "inheritance graph" instead of base and
derived classes.

-- 
Doug Harrison
Visual C++ MVP

On Mon, 12 Jan 2009 13:01:26 -0500, Joseph M. Newcomer




I always thought it interesting that dynamic_cast has to be able to cruise
up and down the inheritance graph and sort of go sideways in MI cases
searching for a match at runtime. As for defining the operator clearly and
rigorously, that's fairly hard to do. The C++ Standard takes a full page to
do it, 1.5 pages with examples. You're interested in the "run-time check"
aspect, and this is what it says:

5.2.7 Dynamic cast
<q>
8. The run-time check logically executes as follows:
If, in the most derived object pointed (referred) to by v, v points
(refers) to a public base class subobject
of a T object, and if only one object of type T is derived from the
sub-object pointed (referred) to
by v, the result is a pointer (an lvalue referring) to that T object.
Otherwise, if v points (refers) to a public base class sub-object of the
most derived object, and the
type of the most derived object has a base class, of type T, that is
unambiguous and public, the result
is a pointer (an lvalue referring) to the T sub-object of the most derived
object.
Otherwise, the run-time check fails.

Note that this is paragraph 8. There are 7 before it. :) Importantly, for
(8) to apply, v (the operand of the cast) has to be a pointer or reference
to a polymorphic type, i.e. a type that has a virtual function.

-- 
Doug Harrison
Visual C++ MVP

Is there a copy of the C++ standard readily available?  The last time I looked it was a
very expensive document.
					joe





>If, in the most derived object pointed (referred) to by v, v points
>>(refers) to a public base class subobject
>>of a T object, and if only one object of type T is derived from the
>>sub-object pointed (referred) to
>>by v, the result is a pointer (an lvalue referring) to that T object.
>>Otherwise, if v points (refers) to a public base class sub-object of the>
>most derived object, and the>
>type of the most derived object has a base class, of type T, that is>
>unambiguous and public, the result>
>is a pointer (an lvalue referring) to the T sub-object of the most derived>
>object.>
>Otherwise, the run-time check fails>
>>/q>
>Note that this is paragraph 8. There are 7 before it. :) Importantly, fo>
>(8) to apply, v (the operand of the cast) has to be a pointer or referenc>
>to a polymorphic type, i.e. a type that has a virtual function.
Joseph M. Newcomer [MVP]
email:  XXXX@XXXXX.COM 
Web:  http://www.**--****.com/ 
MVP Tips:  http://www.**--****.com/ 

On Tue, 13 Jan 2009 02:27:27 -0500, Joseph M. Newcomer




For $30, you can download a .PDF copy here:

 http://www.**--****.com/ %2fISO%2fIEC+14882-2003

-- 
Doug Harrison
Visual C++ MVP

Thanks.  That's a reasonable price.  The last time I looked, it was something over $150,
which is deeply offensive (I believe that all standards should be protected under
something like Creative Commons.  For example, IEEE pays nothing to standards committees,
they are all volunteer and usually funded by the employers of the volunteers, but then
IEEE charges outrageous amounts of money for the machine-readable copies of the volunteer
effort, just because they are IEEE.  One of the reasons, thirty years ago, I refused to
become an IEEE member)
					joe





Joseph M. Newcomer [MVP]
email:  XXXX@XXXXX.COM 
Web:  http://www.**--****.com/ 
MVP Tips:  http://www.**--****.com/ 

Five year ago it was like $22 for the PDF.

On Tue, 13 Jan 2009 21:37:56 -0500, Joseph M. Newcomer




Herb Schildt wrote a book that was an annotated copy of the C Standard, and
people used to buy it just to get a cheap copy of the C Standard. No prizes
for guessing what the standard advice was for the annotations, though.

At least this 2003 edition of the C++ Standard supports copying to the
clipboard. The 1998 version cost only $18 but disabled the Copy feature.
One thing that continues to aggravate about PDF is that Adobe Reader is
really stupid about setting and remembering zoom. For example, even though
I've set "Fit Width" in Preferences, it starts off with the pages too wide
for the window. After I explicitly choose Fit Width from the toolbar, when
I change pages, it reverts to the original too-wide setting. Every time. If
anyone knows how to fix this, I'd love to hear about it.

-- 
Doug Harrison
Visual C++ MVP

The official PDF download has never been exactly expensive ... my 
recollection is that it was originally USD18 ... and the draft was 
free.

You can now download the current working draft (which appears to be the 
1998 standard with change markups for C++ 2009) FREE from:

 http://www.**--****.com/ 

You can also get a handy dead-tree version of the 1998 standard plus 
TC1 from Wiley:
 http://www.**--****.com/ 
/dp/0470846747/ref=pd_rhf_shvl_1 

(I don't remember it costing quite as much as the price quited here ... 
I think I paid about UKP35.00)

Cheers,
 Daniel.
 

I have that book, and I got it for just that reason.  The annotations were useful, too,
and that made it worth the value.

What do you expect?  It's an Adobe product!  I've had the same complaint for years.
				joe





Joseph M. Newcomer [MVP]
email:  XXXX@XXXXX.COM 
Web:  http://www.**--****.com/ 
MVP Tips:  http://www.**--****.com/ 

Not all standards are available in PDF, and some of them are outrageously expensive even
in PDF.  I hadn't looked at the C++ standard in a while, but that's ISO/ANSI, not IEEE.
					joe







Joseph M. Newcomer [MVP]
email:  XXXX@XXXXX.COM 
Web:  http://www.**--****.com/ 
MVP Tips:  http://www.**--****.com/