returning dynamically allocated object through reference

[mundacho]

hello,

I'd like to know if this code is going to create a memory leak in the
calling function:

ili::IntImg
&RectangleImageComparator::synchronize(const ili::IntImg &pImage)
{
ili::IntImg *tempObj = new ili::IntImg(pImage);
return *tempObj;
}


i wanted to return a reference because it's faster because the object
is not copied but passed directly, isn't it?. My question is if the
calling function will free automatically the object returned, if I
do:

// in the calling function I'd do:
ili::IntImg myVar = synchronize(image); // will myVar be destroyed
automatically???

Thanks in advance,

eD

 

[Michael DOUBEZ]

I'd like to know if this code is going to create a memory leak in the
calling function:

ili::IntImg
&RectangleImageComparator::synchronize(const ili::IntImg &pImage)
{
ili::IntImg *tempObj = new ili::IntImg(pImage);
return *tempObj;
}
i wanted to return a reference because it's faster

It is not likely to be, you however have to deference the pointer.

The only advantage would be to ensure that your function won't return
NULL (and errors are handled by exceptions).

because the object
is not copied but passed directly, isn't it?

Yes.
A pointer is also directly passed.

My question is if the > calling function will free automatically the object returned, if I
do:

// in the calling function I'd do:
ili::IntImg myVar = synchronize(image); // will myVar be destroyed
automatically???

No.
You have a memory leak here unless your constructor manages the lifetime
of its parameter.

And no gain in performance, you still have a copy.

You can do:
li::IntImg& myVar = synchronize(image);

But latter on, you would have to call:
delete &myVar;

 

[Zeppe]

hello,

I'd like to know if this code is going to create a memory leak in the
calling function:

ili::IntImg
&RectangleImageComparator::synchronize(const ili::IntImg &pImage)
{
ili::IntImg *tempObj = new ili::IntImg(pImage);
return *tempObj;
}


i wanted to return a reference because it's faster because the object
is not copied but passed directly, isn't it?.

no, it isn't. A object reference may be faster than the corresponding
object (it's not always the case), but returning a pointer is as fast as
returning a reference.

My question is if the
calling function will free automatically the object returned, if I
do:

// in the calling function I'd do:
ili::IntImg myVar = synchronize(image); // will myVar be destroyed
automatically???

No, you have to delete the object you allocated manually to prevent
memory leaks.

Best wishes,

Zeppe

 

[Marcel Müller]

Hi,

no, it isn't. A object reference may be faster than the corresponding
object (it's not always the case), but returning a pointer is as fast as
returning a reference.

I do not agree in general. If you have implicit up-casts together with
multiple inheritance the pointer has to be adjusted by the offset of the
base class in the derived one. But this only applies to non null
pointers. Since references must not be null the compiler can ommit this
check.


Marcel