🚀 go-pugleaf

"Dana Dill" <dana@danadill.com> wrote in message
news:3dde3048@newsgroups.borland.com...
> Actually I am not creating the object in the function.  The function
> accesses the object from a list (it is a lookup function) and returns the
> Object it finds.

Doesn't change the model. If you want to return a new object instance, you
can create one in the function and return that. You will still have to free
the object after you are done with it:

function DoSomething(AObject: TSomeClass): TSomeClass
begin
  ...
  Result:=TSomeClass.Create;
  Result.Assign(AObject);
  ...
end;

Then, somewhere else, you would have:

var
  Source, Destination: TSomeClass;
begin
  ...
  Source:=TSomeClass.Create;
  try
    ...
    Destination:=DoSomething(Source);
    try
      ...
    finally
      Destination.Free;
    end;
    ...
  finally
    Source.Free;
  end;
end;

Also, be careful with the assign. For instance, if your source object
contains references to other objects, the new object will contain references
to the same objects.

> My thinking was since I created a local object  I would have to free it as
> well locally, but of course when I do that it frees the object.

Please read my previous post again: the *reference* to your object is not
the same as the object instance itself. The local reference will go out of
scope, but that does not destroy the instance itself.
The rule is very clear: anything you create, you should destroy after you're
done with it. Interfaces automate some of the lifetime management through
reference counting, but for what you are describing they don't seem a proper
solution.

Guido


--
Guido Gybels
http://www.optimalcode.com/Guido
(Disclaimer: all remarks made apply to Intel processors unless specified
otherwise)