On Fri, Oct 30, 2009 at 3:54 PM, Jeremy Orlow <jor...@chromium.org> wrote:

> On Fri, Oct 30, 2009 at 3:46 PM, Scott Hess <sh...@chromium.org> wrote:
>
>> Just to be clear for those of us who are wobbly on C++, this is
>> because during the constructor or destructor, your object is of the
>> class in question, NOT of the class it will finally be, because in the
>> constructor the subclass has not been constructed, yet, and in the
>> destructor the subclass was already destructed.  So calling to the
>> subclass virtual implementation would be bad.
>>
>> Scott Meyers says: http://www.artima.com/cppsource/nevercall.html
>>
>> Is there any way we could modify an object to assert that it can't
>> happen in development?  Like scoped_vtable_killer declared in the
>> constructor and destructor which makes calling a virtual method on
>> that object fatal?
>>
>
> Or is there any sort of built in compiler warning that we could turn on?  I
> did a bit of searching and was really surprised that I couldn't find any
> mention of such a thing.
>

The compiler could find if it's called directly from the destructor, but
there's no way it'd find your case ! The virtual call happens on another
thread.

To Scott's question: you can blit NULL into the vtable field, if you know
where it is (it's not too hard, but depends on the compiler). You'll know if
you call it - you'll die.
Better yet, you could have a static table of functions that print a message
before dying and blit that one, but that gets trickier.

Antoine


>
> On Fri, Oct 30, 2009 at 3:12 PM, Jeremy Orlow <jor...@chromium.org> wrote:
>> > I've spent a good deal of this week trying to track down what turned out
>> to
>> > be a simple but fairly common problem: I forgot virtual dispatch only
>> > partially works in destructors.  There have been several email threads
>> about
>> > this, but it still bites us form time to time, so I thought it was worth
>> > another reminder.
>> >
>> > Details:
>> > I subclassed ChromeThread which subclasses base::Thread.  base::Thread
>> calls
>> > CleanUp on the thread right before termination.  CleanUp is virtual.
>>  Both
>> > ChromeThread and my class override CleanUp().  base::Thread calls Stop()
>> in
>> > its destructor to stop the thread (if it hasn't already been stopped).
>>  But
>> > by the time you hit destruction, the vtable is no longer available and
>> thus
>> > the destructor of base::Thread (and anything it calls) does NOT have
>> access
>> > to the vtable of ChromeThread (or my class).  So, if you don't
>> explicitly
>> > call Stop(), your subclass's CleanUp method will NOT be called.  Thus
>> the
>> > thread was going away without my CleanUp method ever being called.
>> > Obviously this affects more than just base::Thread.  And this is also
>> how
>> > you can hit errors with pure virtual methods being called.
>> > J
>> > >
>> >
>>
>
>
> >
>

--~--~---------~--~----~------------~-------~--~----~
Chromium Developers mailing list: chromium-dev@googlegroups.com 
View archives, change email options, or unsubscribe: 
    http://groups.google.com/group/chromium-dev
-~----------~----~----~----~------~----~------~--~---

Reply via email to