Array of XY löschen

[Mavarik]

Hallo Zusammen!

Delphi-Quellcode:

Var 

   A : array of byte;

begin
  Setlength(A,1000);

  Setlength(A,0);
  A := NIL;
end.

Ist Setlength(A,0) das gleiche wie A:=NIL?

Mavarik

[Jonas Shinaniganz]

Dynamische Array-Variablen sind implizit Zeiger und werden mit derselben Referenzzählung verwaltet wie lange Strings. Um ein dynamisches Array freizugeben, weisen Sie einer Variable, die das Array referenziert, den Wert nil zu, oder Sie übergeben die Variable an Finalize. Beide Methoden geben das Array unter der Voraussetzung frei, dass keine weiteren Referenzen darauf vorhanden sind. Dynamische Arrays werden immer freigegeben, sobald ihr Referenzzähler null ist. Dynamische Arrays der Länge 0 haben immer den Wert nil.

Ja genau das Gleiche.

Grüße ;)

[s.h.a.r.k]

Delphi-Quellcode:

var 
   A : array of Byte;
begin
  SetLength(A, 1000);
  SetLength(A, 0);
  Writeln(Assigned(A)); // Liefert: FALSE

  SetLength(A, 1000);
  A := nil;
  Writeln(Assigned(A)); // Liefert: FALSE
end.

Ausgehend davon, würde ich sagen ja.

[Jonas Shinaniganz]

Sobald man dem dynamischen Array einen Wert zuweist oder Ihn an SetLength übergibt wird der benötigte Speicher reserviert. Man hat also auch in beiden Fällen keine Speicherlöcher.

[Mavarik]

Danke erstmal..

Aber:

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1180125)

Beide Methoden geben das Array unter der Voraussetzung frei, dass keine weiteren Referenzen darauf vorhanden sind.

Bedeutet? Was könnte den noch eine Referenz habe?

Mavarik

[Uwe Raabe]

Zitat:

Zitat von Mavarik (Beitrag 1180130)

Danke erstmal..

Aber:

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1180125)

Beide Methoden geben das Array unter der Voraussetzung frei, dass keine weiteren Referenzen darauf vorhanden sind.

Bedeutet? Was könnte den noch eine Referenz habe?

Mavarik

Delphi-Quellcode:

type
  TByteArray = array of Byte;

Var 
   A, B : TByteArray;

begin
  Setlength(A,1000);
  B := A;
  A := NIL;
  Writeln(Length(B));
end.

[Jonas Shinaniganz]

Also eine Referenz kannst du ja immer noch irgendwo gespeichert haben. In diesem Fall einen typisierten Pointer.

Delphi-Quellcode:

type
  TMyDynArray = array of Integer;
  PMyDynArray = ^TMyDynArray;

Wenn du jetzt:

Delphi-Quellcode:

var
  MyDynArray : TMyDynArray;
  MyDynArrayPointer : PMyDynArray; 

begin
  MyDynArrayPointer := MyDynArray;
//und dann
  MyDynArray := Nil;

Dann sollte der Array nicht keinen Speicher mehr haben... Sondern erst wenn auch

Delphi-Quellcode:

  MyDynArrayPointer := Nil;

MyDynArrayPointer nicht mehr auf die Speicherstelle zeigt sollte der Speicher freigegeben sein.


OB das allerdings wirklich so ist ist grade reine Spekulation meinerseits... Da müsste doch vielleicht jemand von den älteren und weiseren einmal was zu sagen ;)
Edit:
Habe den Code von Herr Raabe ausgetestet. Ja meine Vermutung war richtig.


Grüße

Edit:
Herr Raabe, haben wir hier Referenzzähler im Hintergrund (Stichwort Smartpointer)?

[himitsu]

Delphi-Quellcode:

SetLength(A, 0);

ist nicht das Gleiche wie

Delphi-Quellcode:

A := nil;

, aber es kommt das selbe Ergebnis bei raus.

Delphi-Quellcode:

:=nil

ruft direkt DynArrayClear auf, wärend SetLength bei 0 an DynArrayClear weiterleitet und sonst was Anderes macht.

@Jonas Shinaniganz: Nein, dem ist nicht so, denn "billige" Pointer besitzen keine Referenzzählung.
Es werden nur Referenzen der Array-Variablen gezählt.


PS: Ihr müßt bei Allem außer den langen Strings aufpassen, mit der Referenzzählung.

Es wird für die Freigabe der Daten zwar auf die Referenzzählung geachtet, aber bei Schreibzugriffen hat mein diese Prüfung total vergessen (seit vielen tausend Jahren schon).

Delphi-Quellcode:

var
  A, B: array ob Byte;

SetLength(A, 3);
A[0] := 132;
A[1] := 456;
A[2] := 798;

B := A;
B[1] := 963;

ShowMessage(IntToStr(A[1]));  // hier würde man ja 456 erwarten, aber erhält 963

[Mavarik]

OK...

Nochmal

Delphi-Quellcode:

Procedure foo;
var
  A ; Array of Byte
begin
  Setlength(A,100);
end;

begin
  for i:=0 to 1000000 do
    Foo;
end;

Speicherbelegung nach der For-Schleife = 0 da jedesmal wenn der "Scope" verlassen wird
die Referent weg ist und somit auch der Speicher, richtig?

Delphi-Quellcode:

var
  A,B ; array of byte
begin
  Setlength(A,3);

  B := A;  // Kopiert den Pointer und nicht den Inhalt, oder?
end;

Mavarik

[himitsu]

Ja

und ja, es kopiert den internen Zeiger und zählt die Referenzzählung hoch, also genauso wie beim langen String.

[Medium]

Zitat:

Zitat von Mavarik (Beitrag 1180150)

Delphi-Quellcode:

var
  A,B ; array of byte
begin
  Setlength(A,3);

  B := A;  // Kopiert den Pointer und nicht den Inhalt, oder?
end;

Ja. Sobald aber...

Delphi-Quellcode:

var
  A,B ; array of byte
begin
  Setlength(A,3);

  B := A; 
  A[0] := $FF; // <---- ...das hier passiert...
end;

...wird der Inhalt "nachträglich" kopiert. (Stichwort: Copy-On-Write) Ab dann sind auch die Referenzen unterschiedlich.

Das aber nur am Rande.

[himitsu]

Zitat:

Zitat von Medium (Beitrag 1180163)

...wird der Inhalt "nachträglich" kopiert. (Stichwort: Copy-On-Write) Ab dann sind auch die Referenzen unterschiedlich.

Wäre schön, wenn es so wäre, aber probier es ruhig mal aus. (siehe ein paar Posts weiter vorne)

Copy-On-Write ist leider nicht aktiv :wall:
Wäre ja zu praktisch, wenn es einen Compilerschalter gäbe, um das für alle/bestimmte Arrays zu aktivieren.

Ein LongString (AnsiString und UnicodeString) ist ja auch "nur" ein (etwas aufbemotztes) dynamisches Array of Char (außer daß der Index bei 1 beginnt, hinten noch ein Feld mehr dranhängt, mit #0 drin, und neuerdings auch noch mit CodePage und CharSize, welche neben dem Referentzähler liegen), aber da funktioniert das Copy-On-Write wenigstens.

[Medium]

:shock: oookay. Aber :shock:!

[himitsu]

Bin darüber leider auch schon gestolpert und voll auf die Fresse gefallen, weil ich damit gerechnet hatte, daß es automatisch umkopiert wird.

Ist richtig toll, weil ich mich nun selber darum kümmern mußte.
Für Strings gibt es UniqueString, womit man dafür sorgen kann, daß es nur eine Referenz in dieser Variable gibt, also falls man mal über wilde Pointer schreibend auf den Stringinhalt zugreifen möchte.

Bei dynamischen Arrays muß man sich dagegen (was auch bei Strings funktiont) mit

Delphi-Quellcode:

SetLength(A, Length(A));

behelfen und hoffen, daß Emba nicht mal auf die Saublöde Idee kommt und intern urplötzlich abprüft, ob sich die Länge wirklich ändert und dann nix macht, was dann sehr blöde enden würde.
[edit] ach stimmt ja, Copy ohne Start+Länge gab's ja auch noch, auch wenn's nicht unbedingt in der OH steht.

[Uwe Raabe]

Zitat:

Zitat von himitsu (Beitrag 1180168)

Ist richtig toll, weil ich mich nun selber darum kümmern mußte.

´

Bei einer reinen Zuweisung

Delphi-Quellcode:

B := A;

wird nur der Pointer auf das Array kopiert und beide Array-Variablen verweisen auf dasselbe Array. Willst du eine separat beschreibbare Kopie, schreibst du eben

Delphi-Quellcode:

B := Copy(A);

[Mavarik]

ehem...

Delphi-Quellcode:

{$H+}
var
  A,B : AnsiString;

begin
  A := 'Cool';
  B := A;
  A := 'UnCool';

  Writeln(B); //Cool 
end;

Wo ist jetzt der Unterschied? Hää jetzt steh ich ganz auf dem schlauch!

Mavarik

[mkinzler]

Zitat:

Wo ist jetzt der Unterschied? Hää jetzt steh ich ganz auf dem schlauch!

Obwohl ein AnsiString eigentlich auch nur ein Zeiger ist, wird der Inhalt bei der Zuweisung kopiert. Spätere Änderungen werden deshalb nicht erkannt.

[Mavarik]

Zitat:

Zitat von mkinzler (Beitrag 1180181)

Obwohl ein AnsiString eigentlich auch nur ein Zeiger ist, wird der Inhalt bei der Zuweisung kopiert. Spätere Änderungen werden deshalb nicht erkannt.

Schon klar. Dann gibt es aber doch noch mehr unterschiede zwichen
DynArrays und Longstrings.

Mavarik

[himitsu]

Zitat:

Delphi-Quellcode:

var
  A,B : AnsiString;

begin
  A := 'Cool';
  B := A;
  A := 'UnCool';

  Writeln(B); //Cool
end;

Zuweisungen auf den kompleten Inhalt sind etwas Anderes.
Das funktioniert auch bei (einfachen) dynamischen Arrays ordnungsgemäß.

Delphi-Quellcode:

var
  A, B: array ob Byte;

SetLength(A, 3);
A[0] := 123;
A[1] := 456;
A[2] := 798;

B := A;

SetLength(B, 3);  // SetLength oder Copy macht B unique und A wird nicht mehr verändert
B[0] := 111;
B[1] := 963;
B[2] := 111;

ShowMessage(IntToStr(A[1]));  // 456
ShowMessage(IntToStr(B[1]));  // 963

Aber zugriffe auf den Inhalt funktionieren eben nicht richtig ... jedenfalls nicht so, wie man es sich denken würde.

Delphi-Quellcode:

var
  A, B: array ob Byte;

SetLength(A, 3);
A[0] := 132;
A[1] := 456;
A[2] := 798;

B := A;

B[1] := 963;

ShowMessage(IntToStr(A[1]));  // hier würde man ja 456 erwarten, aber erhält 963
ShowMessage(IntToStr(B[1]));  // 963

Und hier das selbe Beispiel, nur eben mit einem String.

Delphi-Quellcode:

var
  A, B: string;

A := 'abc';

B := A;

B[2] := 'x';

ShowMessage(A[2] + ' - ' + A); // b - abc
ShowMessage(B[2] + ' - ' + B); // x - axc

[Bummi]

@himitsu
nur so am Rande, wie bekommst Du die Monsterwerte in ein Array of Byte?

[Jonas Shinaniganz]

Ich denke er hat sich nur bei der deklaration vertan, steht ja auch array "ob" byte;

Jedenfalls finde Ich es nicht in Ordnung, dass man 2 Pointer auf die gleiche Speicherstelle hat und beim Zugriff auf Pointer1 mit SetLength() den Array in der Größe verändert und mit Pointer2 bei SetLength() ein neues Array erhält. So kann der SetLength Befehl ja auch als Copy Befehl "missbraucht" werden?

Mich würde die Struktur dieser impliziten Pointer intressieren, gibt es dazu etwas?

Grüße :?

[himitsu]

Zitat:

Zitat von Bummi (Beitrag 1180209)

@himitsu
nur so am Rande, wie bekommst Du die Monsterwerte in ein Array of Byte?

Noch nichts von Datenkomprimierung gehört?
Ich nutze einfach nur die Technik der berühmten Vollbitverschlüsselung, um mehr Daten in jedes einzelne Bit reinzubekommen. :angle:



Byte durch Word oder sonstwas austauschen.


Zum internen Aufbau ... siehe Unit System ... einfach beim Record der Strings abgucken und das eventuell vorhandene CodePage und ElementSize weglassen.
Wobei es hier auch irgendwo mehrere Threads gibt, wo ich den passenden Record schon mehrmals gepostet hatte. (man müßte es nur mal wiederfinden :oops:)