Re: returning dynamically allocated object through reference
On 22 Jan., 04:52, munda...@gmail.com wrote:
I'd like to know if this code is going to create a memory leak in the
calling function (this codes compiles):
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???
"myVar" is a different, new object. It's not the same as the object
that is created by "synchronized(image)". So, you'll be copying the
heap allocated object to the object "myVar" which has automatic
storage. It constitudes a leak because you don't delete the heap
allocated object. The automatic object "myVar" is automatically
destroyed when excecution leaves the scope.
Instead you could write
ili::IntImg & myVar = synchronize(image);
// do something
delete &myVar;
But I'd still consider it to be bad style for several reasons. First,
you still may leak memory due to thrown exceptions in the "do
something" part. Second your function doesn't say anything about who's
responsible for deleting the object. Try to stick to some conventions.
Make function signatures self-explanatory with respect to object
ownership. For example, I don't expect to be responsible for an object
that is returned via a reference or pointer by some function. In your
case the function creates an object and transfers "ownership" (as in
"the caller's responsible for deleting the object"). You could use a
function signature that articulates that. For example:
auto_ptr<IntImg> synchronize(IntImg* pIm);
void draw_image(IntImg* pIm);
:
{
auto_ptr<IntImg> apIm = synchornize(image);
draw_image(apIm.get());
}
// the object 'imp' points to is automatically deleted by
// the auto_ptr's destructor
This is a case where the auto_ptr class template is actually useful.
But you need to be aware of the fact that "copying" auto_ptr objects
is destructive. That's the danger of auto_ptrs.
So, the rules you could follow (to minimize errors) would be:
(1) pointers and references as function parameters/return values DON'T
transfer ownership.
(2) auto_ptr<>s as function parameters/return values DO transfer
ownership.
See "Sink/Source" idiom
http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=390
As mentioned before, these are just conventions. You don't HAVE to do
it that way.
BTW: Since you just copy the object in 'synchronized' and your use of
this function creates another copy you could just write
ili::IntImg myVar (*image);
instead. Though, it's not clear what the function is supposed to do
which is why I can't suggest a design I would use.
Cheers!
SG
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]