Question

This is similar to this question. I asked “Why?” to the most popular response but I don’t know that anyone would ever look at it again. At least not in any timely manner.

Anyway, my question is about best practices for delegating responsibility for creation of objects to functions or procedures, without causing memory leaks. It seems that this:

procedure FillObject(MyObject: TMyObject; SomeParam: Integer);
begin
  //Database operations to fill object
end;

procedure CallUsingProcedure();
var
  MyObject: TMyObject;
begin
  MyObject = TMyObject.Create();
  try
    FillObject(MyObject, 1);
    //use object
  finally
    MyObject.Free();
  end;
end;

is preferred over this:

function CreateMyObject(DBID: Integer): TMyObject;
begin
  Result := TMyObject.Create();
  try
    //Database operations to fill object
  except on E: Exception do
    begin
      Result.Free();
      raise;
    end;
  end;
end;

procedure CallUsingFunction();
var
  MyObject: TMyObject;
begin
  MyObject = CreateMyObject(1);
  try
    //use object
  finally
    MyObject.Free();
  end;
end;

Why?

I’m relatively new to Delphi, having previously worked most with Java and PHP, as well as C++, though to a lesser extent. Intuitively, I lean toward the function method because:

• It encapsulates the object creation code in the function, rather than create the object separately whenever I want to use the procedure.
• I dislike methods that alter their parameters. It’s often left undocumented and can make tracing bugs more difficult.
• Vague, but admittedly it just “smells” bad to me.

I’m not saying I’m right. I just want to understand why the community chooses this method and if there is good reason for me to change.

Edit:
References to @E-Rock in comments are to me(Eric G). I changed my display name.

Answer 1

Creating the object instance and passing it into another procedure makes it clear which code is responsible for freeing the instance.

In the first case (using a procedure to fill it):

MyObj := TMyObject.Create;
try
  // Do whatever with MyObj
finally
  MyObj.Free;
end;

This is clear that this block of code is responsible for freeing MyObj when it’s finished being used.

MyObj := CreateMyObject(DBID);

What code is supposed to free it? When can you safely free it? Who is responsible for exception handling? How do you know (as a user of someone else’s code)?

As a general rule, you should create, use, and free object instances where they’re needed. This makes your code easier to maintain, and definitely makes it easier for someone who comes along later and has to try and figure it out. 🙂