🚀 go-pugleaf

In article <4760hc$llf@cnn.Princeton.EDU> tim@franck.Princeton.EDU
(Tim Hollebeek) writes:

|> In article <475jnr$1sv@engnews1.eng.sun.com>,
|> Steve Clamage <clamage@Eng.Sun.COM> wrote:

|> >Let's restore some context. We were talking about changing the C++ object
|> >model. Under the current model, calls to virtual functions are well-
|> >defined from constructors and destructors: you get the same result as
|> >if the constructor's (destructor's) type were the complete object.

|> They are well-defined, but defined in such a way that is at best
|> confusing and error-prone (despite being consistent and predictable).
|> I recently got bit by this one in the form:

|> ---
|> class A {
|> public:
|>     virtual void close() {
|> 	cerr << "A::close()\n";
|>     }
|>     virtual ~A() {
|> 	cerr << "~A()\n";
|> 	close();
|>     }
|> };

|> class B : public A {
|>     void close() {
|> 	cerr << "B::close()\n";
|>     }
|> };
|> ---

|> The call to close() LOOKS like a normal call to a virtual function,
|> unless you remember that there is an 'exception' in the language for
|> this case.

The call to close() not only looks like a normal call to a virtual
function, it *is* a normal call to a virtual function.  On an object
whose dynamic type is A.

This would seem like the normal behavior to me.

Just out of curiousity, how do other languages which have constructors
and dynamic typing handle this?
--

James Kanze         Tel.: (+33) 88 14 49 00        email: kanze@gabi-soft.fr
GABI Software, Sarl., 8 rue des Francs-Bourgeois, F-67000 Strasbourg, France
Conseils en informatique industrielle --
                              -- Beratung in industrieller Datenverarbeitung



[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]