Re: I don't get it
James Kanze wrote:
On Jun 18, 10:17 pm, Jo <j...@mutools.com> wrote:
John Harrison wrote:
[...]
dynamic_cast does do base to derived conversion, that's it's main use.
Where are you getting your information?
I got that fromhttp://www.cplusplus.com/doc/tutorial/typecasting.html
But i was just reading another webpage where they indeed use
base-to-derived dynamic casts...
Did i misunderstand the cplusplus page?
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.
I understand.
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.)
Indeed, and that's why i was so confused, because i've been using this
many times. (too many it seems now!)
I guess that, by coincidence, i never ran into the combination of using
a void* and multiple inherited objects, and so that's why i only
encountered the errors now.
I'm happy that this has been sorted out, and i completely understand the
reasons beyond it.
All sounds logical.
I'll avoid using void* as much as possible!
And i should use more static_cast / dynamic_cast instead of the old
c-style casts, because they're more error-conscious.
(a pity of that quircky syntax though)