Re: I don't get it

On Jun 18, 10:17 pm, Jo <j...@mutools.com> wrote:
 


   [...]
 


 


 


 


You didn't read the sentence completely. It says: "The second
conversion in this piece of code would produce a compilation
error since base-to-derived conversions are not allowed with
dynamic_cast UNLESS the base class is polymorphic." Note that
final clause, with the unless. In their example, the base class
didn't have any virtual functions, so using dynamic_cast to the
derived would be a compiler error.

Generally speaking, you should avoid using void* as much as
possible, and use dynamic_cast exclusively for moving between
classes in a hierarchy. When you can't avoid void*, e.g.
because of legacy or C interfaces, always cast back to exactly
the type of pointer you originally had, then go from there.
Note that often, this means casting to a specific type before
casting to void*. For example (using pthread_create as an
example, but it could be any C API function that takes a pointer
to function and a void*):

   class Thread
   {
   public:
       virtual ~Thread() {}
       virtual void* run() = 0 ;
   } ;

   extern "C"
   void*
   threadStarter( void* p )
   {
       Thread* t = static_cast< Thread* >( p ) ;
       return t->run() ;
   }

   void
   f()
   {
       // MyThread derives from Thread...
       pthread_t t ;
       pthread_create( &t, NULL, &threadStarter, new MyThread ) ;
   }

As written, this is undefined behavior. The last code line must
be:

   pthread_create(
       &t, NULL, &threadStarter, static_cast< Thread* >( new
MyThread ) ) ;

(The problem is, that as it is undefined behavior, it might seem
to work some of the time anyway. On most implementations, for
example, it will seem to work as long as only single inheritance
is involved.)