🚀 go-pugleaf

A question arose in our internal C++ class.  The instructor was
describing a bug to look out for in some C++ compilers.  The
code was something like this:

class bug {
    bug() { cout << "in constructor" }
   ~bug() { cout << "in destructor"  }
}
main()
{
    bug a,b;
    foo(a,b);
}
foo(bug a, bug b)
{
    cout << "in foo";
}

The output of a cfront based compiler was

in constructor
in constructor
in foo
in destructor
in destructor

While on some other compilers (TC++, Zortec, G++, versions unknown) the
output was

in constructor
in constructor
in foo
in destructor   <-- apparently destructed in foo()
in destructor   <-- apparently destructed in foo()
in destructor
in destructor

We agreed that it was a bug that #constructors != #destructors, but had
a disagreement about whether the number of constructor/destructor pairs
should have been 2 or 4.

So my question:  Should a constructor/destructor be called for a formal
parameter that has been passed by value?  Some people said yes, because
it is coming into/out of scope.  Some people said no, because it had
already been copied onto the stack and therefore existed.  Our instructor
said it was implementation defined, but I can't believe that this is
true.  Any references that anyone can give me?

Thanks in advance,
Mark.
-- 
Mark Harrison             harrison@necssd.NEC.COM
(214)518-5050             {necntc, cs.utexas.edu}!necssd!harrison
standard disclaimers apply...