NetNews Usenet Archive 1992 #30/NN_1992_30.iso/spool/comp/lang/cplus/18122

Text File | 1992-12-17 | 3.1 KB | 105 lines

Path: sparky!uunet!mcsun!julienas!sophia!hawai.inria.fr!gchow
From: [e-mail] (Gloria Chow)
Newsgroups: comp.lang.c++
Subject: Matrix Addition  Was Re: Complex Addition.
Keywords: operator, memory leak
Message-ID: <[e-mail]>
Date: 13 Dec 92 16:33:47 GMT
References: <[e-mail]> <[e-mail]>
Sender: [e-mail]
Organization: INRIA, Sophia-Antipolis (Fr)
Lines: 92

In article <[e-mail]>, [e-mail] (Pete Becker) writes:
|> In article <[e-mail]> [e-mail] (Guy Pickering) writes:
|> >In ARM, the code for the `+` operator for the complex class is given as:
|> >
|> >inline complex operator+(complex a, complex b)
|> >{
|> >  return complex(a.re+b.re,a.im+b.im)
|> >}
|> >
|> >In general, can I create an instance of a class in a member function and
|> >return the object? Doesn't the complex object go out of scope?
|> >
|>
|>     Yes, it does.  But that's not the end of the inquiry.
|>
|>     int add( int a, int b )
|>     {
|>     return a+b;
|>     }
|>
|>     Here, too, the temporary goes out of scope, but the compiler knows how
|> to deal with that.  Same thing for an object of a user-defined type.
|>

How about if the structure is a bit more complex, especially one with
dynamically allocated memory.  I tried the following (I appologize if it's
syntactically incorrect, I no longer have the version which I actually tried.
This one is just from memory):

class MATRIX
{
protected:
    double      **entry;
    int         nrows, ncols;
public:
    MATRIX( int num_rows, int num_cols );
    MATRIX& operator=( const MATRIX& equivalent );
    MATRIX& operator+( const MATRIX& addend );
};

MATRIX::MATRIX(int num_rows, int num_cols )
{
register int    i;

    nrows = num_rows;
    ncols = num_cols;

    entry = new double *[ nrows ];
    for( i=0 ; i<nrows; i++ )
        entry[i] = new double[ ncols ];
}

MATRIX& MATRIX::operator=( const MATRIX& equivalent )
{
register int    i;

    for( i=0; i<nrows; i++)
        memcpy( (void*)entry[i],
                (void*)equivalent.entry[i],
                sizeof( double ) * ncols);

    return *this;
}

MATRIX& MATRIX::operator+( const MATRIX& addend )
{
register int    i,j;
MATRIX          sum(nrows, ncols);

    for( i=0 ; i<nrows ; i++ )
        for ( j=0 ; j<ncols ; j++ )
            sum.entry[i][j] = entry[i][j] + addend.entry[i][j];

    return sum;
}


Okay, the problem is when I tried to use the "+" operator as follows:

    matrix_c = matrix_a + matrix_b;

the "+" operation works and sum contains the proper matrix, that is until
"+" finishes and goes out of scope.  The "return" statement makes a temporary
copy of sum (ie. the values of its nrows, ncols, and the pointer entry), and
then proceed to destroy sum automatically.  So, now the entry pointer of this
temporary is no longer pointing to a valid block of memory!!

Is this really what happened?  I am new to C++, I am not sure my interpretation
is correct.  But all I can tell is that this simple addition and assignment
sequence DOESN'T work, and I don't know how to get around it.  HELP!!

gloria