Re: I don't have to tell you...
* Howard Beale:
Alf P. Steinbach wrote:
Jeez, where do you pick up such misconceptions?
What's miconceived?
C++ FAQ [23.5]:
- "When my base class's constructor calls a virtual function on its this
object, why doesn't my derived class's override of that virtual function
get invoked?"
http://www.parashift.com/c++-faq-lite/strange-inheritance.html#faq-23.5
This is good. It's the official C++ FAQ. Since you're using it as authority I
mention that some of that stuff further down originated with me. :-)
http://www.artima.com/cppsource/nevercall.html
- "Never Call Virtual Functions during Construction or Destruction"
This, however, is total bullshit.
In the technical sense, that is.
Thanks for pointing it out!
One could argue that it's good thing for C++ not to allow this, but I'd
simply point out that more recent languages don't have a problem with it:
http://www.andymcm.com/csharpfaq.htm#3.9
On the contrary, Java and C# have very dangerous problems with virtual calls
from constructors.
It's one of the most common bugs in Java applications (you can get a subclass
method invoked before the subclass object has been initialized).
In C++ virtual calls from constructors are safe, with one exception, namely a
call of a pure virtual.
The FAQ explains how it works in C++, but just if you don't want to spend on
time on finding that:
In C++, during a constructor of type T, the '*this' object is of most derived
type (dynamic type) T -- so everything works as the author of class T expects,
no matter whether this constructor call originated from some subclass.
Yes, I know that it's recommended (in C#) not to call virtual functions
from constructors / destructors, but it is supported and will work the way
you expect. The danger is just that someone else overriding your virtual
function may unknowingly alter the behavior of construction / destruction.
It's a bit more dangerous that in Java/C#; see above.
Cheers & hth.,
- Alf