Temporary objects deleted to soon?

Question

bash-3.2$ uname -a
SunOS solaris 5.11 snv_86 i86pc i386 i86pc
bash-3.2$ CC -V
CC: Sun C++ 5.9 SunOS_i386 2007/11/15
I believe that the C++ compiler is producing incorrect results with respect
to the creation and destruction of temporary variables when using operator
overloading.
The code sample below is compiled using:
bash-3.2$ CC -o huh6.exe huh6.C -features=tmplife -features=strictdestrorder
// begin code: huh6.C
#include  <stdio.h>
#include  <stdlib.h>
class AClass {
public:
    double *a;
    AClass( double x = 0 );
    ~AClass( void ) {
        //printf("<<<AClass variable deleted>>>\n");
        delete [] a;
    AClass& operator=( const AClass &right );
    friend AClass operator+( const AClass &left, const AClass &right );
AClass::AClass( double x ) {
    a = new double[1];
    a[0] = x;
    //printf("***AClass variable created***\n");
AClass& AClass::operator=( const AClass &right ) {
    a[0] = right.a[0];
    return( *this );
AClass operator+( const AClass &left, const AClass &right ) {
    AClass tmp;
    tmp.a[0] = left.a[0] + right.a[0];
    return( tmp );
int main() {
    AClass f, g, x, y, z;
    x.a[0] = 1.0; 
    y.a[0] = 2.0;
    z.a[0] = 3.0;
    f = x + y + z;
    printf("(1) f.a = %e\n", f.a[0]);
    g = x + y;
    g = g + z;
    printf("(2) g.a = %e\n", g.a[0]);
    return(0);
// end code huh6.C
Execution of the program yields:
bash-3.2$ ./huh6.exe
(1) f.a = 3.000000e+00
(2) g.a = 6.000000e+00
The expected result is
(1) f.a = 6.000000e+00
(2) g.a = 6.000000e+00
By uncommenting the printf statements it will be noted that the temporary
variables are deleted too soon.
Is there a compiler option that I am missing?
Thanks in advance.
===================================
The g++ compiler (using Linux/Mac OS X/OpenBSD/FreeBSD) produces:
(1) f.a = 6.000000e+00
(2) g.a = 6.000000e+00

Answer 1

The code involves copying AClass objects to create temps, and you don't have a copy constructor. The compiler-generated copy constructor copies the pointer 'a' in the class, and when one of the copies is destroyed, the data in the other copy is also destroyed.
Add a copy constructor similar to the one below and your code should behave as you expect.
AClass::AClass( const AClass &c ) {
    a = new double[1];
    a[0] = c.a[0];
    // printf("copy    from %p to %p\n", &c, this);
}