Hi,

I understand right that (as I have asked before) an empty (ansi)string is equal to NIL.

If this is correct, is setting a string to '' the same as setting the string to NIL?

So i can e.g. use exchagably:

{$H+}
var
  s: string;
begin
  s := 'something';
  { this ... }
  s := '';
  { ... works equally to that: }
  s := NIL;

And more: is the memory consumed by the string freed using one of the two methods?

TIA,
Marc

Marc Santhoff wrote

I understand right that (as I have asked before) an empty (ansi)string is equal to NIL.

True.

If this is correct, is setting a string to '' the same as setting the string to NIL?

No.

No, because "s:=nil" doesn't compile. And pointer(s):=nil would create
a memory leak.

And more: is the memory consumed by the string freed using one of the two methods?

It is freed if you use s:='' (but keep in mind the earlier discussion about reference counted types: the memory may not be freed immediately, because there may still be hidden references lingering around for a while).

Jonas

Mumble ...

And pointer(s):=nil would create a memory leak.

That's the important part, I'm dealing with cleanly freeing strings when destroying objects.

> And more: is the memory consumed by the string freed using one of the > two methods? It is freed if you use s:=''

This is the way to do it, OK.

(but keep in mind the earlier discussion about reference counted types: the memory may not be freed immediately, because there may still be hidden references lingering around for a while).

I will.

Many thanks,
Marc

That's the important part, I'm dealing with cleanly freeing strings when destroying objects.

I may be wrong but I think you don't need to do anything, when you free a class the memory used by string fields is automagically freed (either that or heaptrc is lying[*] when it says my programs aren't leaking memory)

[*]though I know of at least a nasty leak with gtk2 under lazarus that heaptrc didn't trace.

Bye

Which one?

Mattias

Yup. Ansi strings, refcounted interfaces and dyn arrays are automagically freed when declared as class members and you destroy the instance.

Joao Morais

En/na Mattias Gaertner ha escrit:

> [*]though I know of at least a nasty leak with gtk2 under lazarus that > heaptrc didn't trace. Which one?

http://bugs.freepascal.org/view.php?id=9259
(I just noticed you fixed it, but heaptrc didn't report anything when I first discovered it).

Bye

Heaptrc only checks the FPC heap. But in this case it was gtk memory. So you need something like valgrind.

Mattias

So as a rule of thumb strings can be used like any other non-object and non-heap variable, as long as they are declared in the context of a class.

If other objects or vars are holding pointers, ref counting prevents freeing strings still needed.

Marc

That's interesting and nice. Can I assume the same is valid for dyn arrays in a procedure or function context?

Normal vars do "behave" that way ...

program x;
procedure a;
var
  s: array of string;
begin
  SetLength(s, count);
  s[0] := 'a string';
  ... do something ...

end; { no freeing of the array strings needed? }

Marc

Marc Santhoff wrote

That's interesting and nice. Can I assume the same is valid for dyn arrays in a procedure or function context?

The short answer is yes.

There was recently (about a month ago) a discussion about some of these very issues, from 21 to 29 June. I'd encourage you to read it.

(Unfortunately I erroneously made the subject line "memory management with open arrays and classes"; and I replied to another thread instead of starting a new thread, so the messages don't appear in a nice little self-contained thread. doh!)

...and three messages following; make sure you read the one by Jonas, as the first reply contains some misinformation.

~David.

Indeed not. Even if s was an array of ansistrings, they would still be cleaned up automatically when the var goes out of scope.

Marc