SetLength mein problem

[EWeiss]

Hi

Zitat:

Ich hoffe das hilft und löst nicht wieder Beleidigungen aus...

Hilft sehr! Lößt auch keinerlei beleidigungen aus
Im Magnetic thread war ich etwas sauer das du mich hast auflaufen lassen.
Hättest du direkt gesag das es nicht geht, hätten wir uns anschließende Diskussionen
sparen können.. Aber denke das ist erledigt. (zumindest für mich).
Ich entschuldige mich aber nocheinmal dafür.

Dieser Thread ist auch keine Übersetzung sondern ein kompletter neuanfang.
Da ich bemerkt habe das es nichts bringt irgendeinen VB Code übersetzen zu wollen.

Zitat:

Warum ein Array von Zeigern auf den Record anstatt eines Arrays of Records?

Delphi-Quellcode:

AWindowDescr = array of PWindowDescr;  
//Array von Zeigern auf den Record

AWindowDescr = array of TWindowDescr;  
//Array auf den Record

Was ist genau der unterschied ?

Zitat:

also werden hier 101 Elemente angelegt, Zugreifbar mit Index 0 bis 100

Ja stimmt.
Es gab da ein problem wenn ich mit dem Array(0) begonnen habe die Daten zu füllen
werde ihn auf 99 setzen muss dann allerdings schauen ob nach allen änderungen
wieder ein AV auftritt.

Zitat:

warum holst du dir den Speicher für nur einen Record (den an Index 100)? Was ist der Sinn?

Ich habe gelesen das New eine ähnliche funktion wie Redim in VB ist.
Bin aber mittlerweile darauf gekommen das dadurch zuerst der Index(100) mit Daten gefüllt wird.
Ist also verkehrt meine vermutung.

Zitat:

Ich glaube der erste Parameter müsste noch ein ^ bekommen, weil sonst
schreibt ZeroMemory die Array-Pointer-Liste mit 0'en voll anstatt des Records

Könntest du mir bitte genau die function 'ZeroMemory' erklären ?
Welche parameter genau was machen.

Zitat:

warum? Willst du Index 0 nicht nutzen? Wenn vor dem Until ein Inc(IntI)

Weil wie oben beschrieben bei 0 ein AV auftrat ..
Habe inc(IntI); nun ans ende der until schleife gesetzt damit wird der Index 0 nun auch benutzt.

Zitat:

SetLength(wDescr, High(wDescr) + 10);
High() gibt dir den höchsten Index an, aber nicht die Anzahl der Elemente.
SetLength() will die Anzahl der neuen Elemente, also Anzahl der Elemente bisher + 10, sprich:
SetLength(wDescr, Length(wDescr) + 10);

Habe angenommen das der höchste wert high(wDescr) = 100 wenn Index= 99 geändert .. mit 10 addiert werden kann.
Wäre auch irgendwie logisch. ?

Zitat:

New(wDescr[IntI]);
beachte hier: es ist der Index 100 schon initialisiert!

Ja. aber nicht der 110 wenn mehr als 100 Fenster gefunden wurden. Oder ?

Zitat:

ZeroMemory(wDescr[IntI], SizeOf(wDescr[IntI]^));
siehe oben: 1. Parameter sollte noch ein ^ bekommen

wenn ich das Array AWindowDescr = array of TWindowDescr; setze kommt nun nach der änderung von
ZeroMemory(wDescr[IntI]^, SizeOf(wDescr[IntI]^)); folgende Fehlermeldung
[Pascal Error] Unit2.pas(235): E2017 Pointer type required
lasse ich den Zeiger^ weg diese
[Pascal Error] Unit2.pas(235): E2010 Incompatible types: 'Pointer' and 'TWindowDescr'
Vorher hatte ich bei AWindowDescr = array of PWindowDescr; keine Fehlermeldungen.
Wo ist nun der unterschied ?

Zitat:

SetLength(wDescr, IntI);
wenn du oben das mit dem Inc(IntI) änderst, dann hier Succ(IntI) als höchstes Element setzen

Verstehe ich auch nicht ganz ?
Nach dem durchlauf der Schleife hat doch IntI autmatisch den höchsten index
warum muss er dann mit Succ(IntI) explizit zugewiesen werden ?

gruß

[Muetze1]

Hi!

Zitat von EWeiss:

Im Magnetic thread war ich etwas sauer das du mich hast auflaufen lassen.

Wollte und habe ich meines Wissens nach nicht.

Zitat von EWeiss:

Hättest du direkt gesag das es nicht geht, hätten wir uns anschließende Diskussionen
sparen können.

Dachte das hätte ich. Da ich auch eine Lösung in Delphi anbieten wollte, wollte ich die ganze Zeit wissen, was dieses Speicher schreiben bei der Instanzenadresse bewirkt bzw. macht. Daher hatte ich dies so oft gefragt.

Zitat von EWeiss:

Ich entschuldige mich aber nocheinmal dafür.

Ist Schnee von gestern...

Zitat von EWeiss:

Delphi-Quellcode:

AWindowDescr = array of PWindowDescr;  
//Array von Zeigern auf den Record

AWindowDescr = array of TWindowDescr;  
//Array auf den Record

Was ist genau der unterschied ?

Beim Ersten hast du ein Array von Zeigern auf den Typ des Records. Wenn du das Array vergrösserst oder verkleinerst stellt dir das Array nur Platz für einen Zeiger pro Eintrag zur Verfügung. Sprich: Du bekommst pro Eintrag 4 Bytes von dem Array gestellt. Dieser zeigt ins Nirvana und nicht auf einen alloziierten Speicherbereich. Aus diesem Grund musst du mit New() dir Speicher alloziieren (in der Grösse des Records - und das macht New() automatisch (die Grösse ermitteln) und gibt dir einen Zeiger auf diesen alloziierten Speicherbereich in Grösse des Records zurück). Durch das Zurückgeben des Pointers wird dieser im Array an der Position eingetragen.

Beim Zweiten hast du ein Array wo jedes Element direkt ein Record ist. D.h. ein Eintrag in dem Array ist SizeOf(TWindowDescr) gross. Du bekommst hier im Gegensatz zum Ersten nicht nur 4 Bytes der erst auf den Record zeigt sondern du hast direkt hier den Record liegen.

Zitat von EWeiss:

Zitat:

also werden hier 101 Elemente angelegt, Zugreifbar mit Index 0 bis 100

Ja stimmt.
Es gab da ein problem wenn ich mit dem Array(0) begonnen habe die Daten zu füllen
werde ihn auf 99 setzen muss dann allerdings schauen ob nach allen änderungen
wieder ein AV auftritt.

Wieso 99? Ich verstehe es nicht. Ich weise nochmals auf den Unterschied bei den Begrifflichkeiten der Indexe und der Anzahl hin! Wenn ein Array 100 Elemente hat, dann sind die Index 0 bis 99 gültig. Da 0 auch ein gültiger Eintrag ist, wird 0 mitgezählt. Daher ist immer zu unterscheiden ob es nun um die Anzahl der Elemente geht oder um den höchsten Index. Der höchste Index ist bei einem dynamischen Array immer eins unter der Anzahl der Elemente!

Zitat von EWeiss:

Zitat:

warum holst du dir den Speicher für nur einen Record (den an Index 100)? Was ist der Sinn?

Ich habe gelesen das New eine ähnliche funktion wie Redim in VB ist.
Bin aber mittlerweile darauf gekommen das dadurch zuerst der Index(100) mit Daten gefüllt wird.
Ist also verkehrt meine vermutung.

Redim würde in Delphi dem SetLength() entsprechen und New()/Dispose() sind Delphi Funktionen um Speicher zu alloziieren und frei zu geben. Dabei sind New() und Dispose() vergleichbar mit GetMem() und FreeMem() aber mit dem Unterschied, dass New()/Dispose() den Typ mit auswerten und entsprechend der Grösse des Typens den Speicher alloziieren (siehe SizeOf()). GetMem()/FreeMem() wollen immer die Grösse des Speicherbereichs übergeben bekommen.

Zitat von EWeiss:

Zitat:

Ich glaube der erste Parameter müsste noch ein ^ bekommen, weil sonst
schreibt ZeroMemory die Array-Pointer-Liste mit 0'en voll anstatt des Records

Könntest du mir bitte genau die function 'ZeroMemory' erklären ?
Welche parameter genau was machen.

ZeroMemory() ist ein von der MSDN übernommenes Makro zum leeren des Speichers. Dieses verlangt einen Pointer und einen Integer. Der Pointer gibt den mit 0'en aufzufüllenden Speicher an und der Integer die Grösse des Speicherbereichs in Bytes. Ich hatte das mit dem ^ falsch geschrieben. Ich hatte gestern an FillChar() gedacht, da wäre der Parameter kein Pointer sondern ein Var Parameter und dort wäre das ^ nötig gewesen. Bei ZeroMemory() sollte von daher das ^ auch bei einem Array Of PWindowDescr nicht nötig sein.

Zitat von EWeiss:

Zitat:

SetLength(wDescr, High(wDescr) + 10);
High() gibt dir den höchsten Index an, aber nicht die Anzahl der Elemente.
SetLength() will die Anzahl der neuen Elemente, also Anzahl der Elemente bisher + 10, sprich:
SetLength(wDescr, Length(wDescr) + 10);

Habe angenommen das der höchste wert high(wDescr) = 100 wenn Index= 99 geändert .. mit 10 addiert werden kann.
Wäre auch irgendwie logisch. ?

Nein, wie oben beschrieben. Length() liefer die Anzahl der Elemente im Array. High() liefert den höchsten Index im Array. Und bei einem dynamischen Array gilt immer: Höchster Index = Anzahl Elemente - 1. Mit anderen Worten: High(Array) = Length(Array) - 1.

Zitat von EWeiss:

Zitat:

New(wDescr[IntI]);
beachte hier: es ist der Index 100 schon initialisiert!

Ja. aber nicht der 110 wenn mehr als 100 Fenster gefunden wurden. Oder ?

Ich bezog mich damit auf das Array Of PWindowDescr. Da wäre, wie oben beschreiben, jeder Eintrag des Arrays ein Zeiger in 's Datennirvana und daher müsste für jeden Eintrag mit New() Speicher angefordert werden und der Zeiger auf diesen in das Array eingetragen werden. New() alloziert bei deinem Aufruf nur einmail den Speicher für einen Record und legt den Zeiger auf diesen in dem Array ab. Daher wäre nur ein einziger Arrayeintrag initialisiert und alle anderen auch weiterhin undefiniert.

Zitat von EWeiss:

Zitat:

ZeroMemory(wDescr[IntI], SizeOf(wDescr[IntI]^));
siehe oben: 1. Parameter sollte noch ein ^ bekommen

wenn ich das Array AWindowDescr = array of TWindowDescr; setze kommt nun nach der änderung von
ZeroMemory(wDescr[IntI]^, SizeOf(wDescr[IntI]^)); folgende Fehlermeldung
[Pascal Error] Unit2.pas(235): E2017 Pointer type required
lasse ich den Zeiger^ weg diese
[Pascal Error] Unit2.pas(235): E2010 Incompatible types: 'Pointer' and 'TWindowDescr'
Vorher hatte ich bei AWindowDescr = array of PWindowDescr; keine Fehlermeldungen.
Wo ist nun der unterschied ?

Wie oben beschrieben: Vorher hattest du ein "Array Of Pointer auf bestimmten Typ" und nun hast du ein "Array Of bestimmten Typ". Einen Zeiger kann man dereferenzieren (Was das ^ macht), d.h. an der Stelle wo das ^ angehangen wird, wird nicht mit dem Zeiger gearbeitet sondern mit der Stelle wo er hinzeigt. Dies geht bei einem Array Of Record nicht mehr - da ist kein Pointer.

Zitat von EWeiss:

Zitat:

SetLength(wDescr, IntI);
wenn du oben das mit dem Inc(IntI) änderst, dann hier Succ(IntI) als höchstes Element setzen

Verstehe ich auch nicht ganz ?
Nach dem durchlauf der Schleife hat doch IntI autmatisch den höchsten index
warum muss er dann mit Succ(IntI) explizit zugewiesen werden ?

Zuvor hast du den Inc(IntI) am Anfang der Repeat/Until gemacht und damit ist nach der Schleife IntI der höchste Index - aber du hast zu dem Zeitpunkt aber IntI + 1 Einträge (auch hier wieder höchster Index <> Anzahl Elemente!). Daher würde ein SetLength() auf IntI zur Freigabe des letzten Eintrages führen. Succ() liefert den Nachfolger, also würde bei einem Integer IntI im Endeffekt IntI + 1 rauskommen, was wiederrum der Anzahl der Einträge entspricht, da nun der 0. Index mitgezählt wurde. Siehe dazu auch den Zusammenhang: High(Array) = Length(Array)-1. SetLength() möchte immer die Anzahl und Length() liefert immer die Anzahl und nicht den höchsten Index.

[EWeiss]

Zitat:

Beim Zweiten hast du ein Array wo jedes Element direkt ein Record ist. D.h. ein Eintrag in dem Array ist SizeOf(TWindowDescr) gross. Du bekommst hier im Gegensatz zum Ersten nicht nur 4 Bytes der erst auf den Record zeigt sondern du hast direkt hier den Record liegen.

Ich habe es insoweit verstanden und hoffe das ich es jetzt richtig interpretiere.
Wenn ich kein Array von Zeigern auf den Typ des Records verwende benötige ich kein New() mehr
da ich den Record direkt zur verfügung habe.
Das bedeutet auch ich benötige ebenfalls ZeroMemory nicht mehr.

Demnach sieht mein Code nun so aus!

Delphi-Quellcode:

 PWindowDescr = ^TWindowDescr;
 TWindowDescr  = record
    hWnd      : HWND;
    ProcessID : Pointer;
    Title     : String;
    Klass     : String;
    ExeName   : String;
End;
    AWindowDescr = array of TWindowDescr;

Var
  wDescr   : AWindowDescr;

// Alle offene Fenster suchen.
Function GetWindowList(var wDescr: AWindowDescr): DWORD;
Var
  IntI  : Integer; // Zähler füt die Fenster Handle
  h_wnd : HWND;    // Fenster Handle
Begin
    // Zähler initialisieren
    IntI := 0;
    h_wnd := GetTopWindow(0);
    // Zuweisen von 100 Array Elementen of PWindowDescr
    // Zum einlesen der Fenster Handle
    SetLength(wDescr, 100);

    Repeat
      // Wenn mehr als 100 Fenster Handle gefunden
      If IntI > High(wDescr) Then
        // Array um 10 erhöhen
        SetLength(wDescr, Length(wDescr) + 10);
        // Fenster Handle ermitteln
        h_wnd := GetWindow(h_wnd, GW_HWNDNEXT);
        // Fenster Handle gefunden
        If h_wnd <> 0 Then
         begin
           // Wert zuweisen
           wDescr[IntI].hWnd := h_wnd;
           // Window Informationen einlesen
           GetWindowInfo(@wDescr[IntI]);
         end;
         // Zähler um 1 erhöhen
         inc(IntI);
    // Schleife durchlaufen bis kein Fenster Handle mehr existiert
    until h_wnd = 0;

    // Array Redimensionieren Fenster-Handle Count
    SetLength(wDescr, succ(IntI));
    // Ergebnis übergeben
    Result := succ(IntI);

End;

Zitat:

Wieso 99? Ich verstehe es nicht. Ich weise nochmals auf den Unterschied bei den Begrifflichkeiten der Indexe und der Anzahl hin! Wenn ein Array 100 Elemente hat, dann sind die Index 0 bis 99 gültig. Da 0 auch ein gültiger Eintrag ist, wird 0 mitgezählt. Daher ist immer zu unterscheiden ob es nun um die Anzahl der Elemente geht oder um den höchsten Index. Der höchste Index ist bei einem dynamischen Array immer eins unter der Anzahl der Elemente!

Denke da reden wir aneinandner vorbei ich meinte den Index := 100 diesen nach Index := 99 ändern.. ergibt 100 elemente
Brauchen tu ich diesen aber auch nicht mehr da ich es geändert habe
SetLength(wDescr, 100);

Zitat:

Ich hatte das mit dem ^ falsch geschrieben. Ich hatte gestern an FillChar() gedacht, da wäre der Parameter kein Pointer sondern ein Var Parameter und dort wäre das ^ nötig gewesen. Bei ZeroMemory() sollte von daher das ^ auch bei einem Array Of PWindowDescr nicht nötig sein.

Ja das hatte ich bemerkt es hatte nämlich AV's als rückgabe
Da ich nun direkt den Record einlese hat sich das erstmal erledigt aber destotrotz Danke für die Infos
kann bei erneuter verwendung dann darauf zurückgreifen (Thread als .PDF abspeichern) feine Sache.

Gruß

[Der_Unwissende]

Zitat von EWeiss:

Wenn ich kein Array von Zeigern auf den Typ des Records verwende benötige ich kein New() mehr
da ich den Record direkt zur verfügung habe.
Das bedeutet auch ich benötige ebenfalls ZeroMemory nicht mehr.

Hi, mal ein paar Worte zur eigentlichen Frage (die war noch frei von Code glaube ich).
Also erstmal solltest du hier wirklich zwischen Arrays und Records unterscheiden, new wirst du tatsächlich nie direkt im Zusammenhang mit einem Array verwenden müssen/sollen/brauchen. Darauf komme ich aber nachher zurück.
An sich ist ein Array in fast allen Programmiersprachen vorhanden. An sich hat das nichts mit veraltet oder nicht zu tun, die Struktur ist einfach denkbar einfach und hat (je nach Implementierung) sehr wenig Overhead (keine indirection nötig).
Ein Array kannst du dir immer (vereinfacht, wenn auch nicht viel) als ein Stück Speicher vorstellen. Hast du ein Array vom Typ T mit n Elementen, dann würde hier einfach n * sizeOf(T) Speicher reserviert werden (+ 32 Bit für die Größe). Wichtig ist hier aber einfach die Tatsache, dass du nur ein Stück Speicher hast, dass genau die n mal die Struktur T aufnehmen kann und die direkt hintereinander im Speicher liegen (die Ts). Wenn du die Position des ersten Elements im Speicher kennst, dann kannst du genau diese Eigenschaft ausnutzen. Ausgehend von der Position des ersten Elements, liegt das zweite gerade an der Adresse des ersten + sizeOf(T). Würdest du hier + 2*sizeOf(T) addieren, landest du beim dritten Element...
Du kannst hier also ausgehend von der Adresse des ersten Elements direkt die Adresse aller anderen Elemente berechnen. Dies macht Arrays einfach sehr perfomant.

Der Unterschied zwischen einem statischen Array und einem Dynamischen liegt natürlich in der festen Größe des statischen Arrays, aber hier wären noch weitere Unterschiede zu finden. So wird ein statisches Array aut. aus dem Speicher entsorgt und der Index kann an einer beliebigen Stelle beginnen.
Variablen die als dyn. Array deklariert werden speichern nur einen Zeiger auf das Array. Bevor du dein Array nicht mit setLength initialisierst, gibt es hier einfach keinen Speicher, der wirklich zu dem Array gehört. Während der Zeiger bei einer Instanz- oder Globalen-Variable noch initialiert wird (= nil), ist dies innerhalb von Methoden/Funktionen nicht der Fall. Hier könntest du also einen gültigen Zeiger haben, von dem du aber nicht weißt, wo dieser hinzeigt. Ist dein dyn. Array nicht initialisiert, führt jeder Zugriff auf ein Element im Array zu einem zufälligen Speicherzugriff. Beim Lesen wirst du hier nur unerwartete Werte finden, beim Schreiben kann es sein, dass du den Speicher eines anderen Teils deines Programms überschreibst. Nur im besten Fall wirst du das sofort merken, im schlimmsten Fall ist das ein sehr sehr schwer zu lokalisierender Fehler!
Deshalb gilt es immer, dyn. Arrays auch zu initialisieren. Die Länge legst du dabei mit setLength fest und erhälst hier den Zeiger auf das erzeugte, Null indexierte Array. Doch auch hier musst du aufpassen. Da du nur einen Zeiger auf das Array hast, musst du selbst dafür sorgen, dass die dahinter liegenden Daten nicht als unerreichbarer Müll im Speicher bleiben. Es ist immer sauber, dyn. Arrays explizit frei zu geben. Dazu rufst du finalize(<ARRAY>) und setLength(<ARRAY>, 0) auf. Damit stellst du sicher, dass der hier allozierte Speicher sofort (an dieser Stelle) frei gegeben wird.
Das ist eigentlich schon so ziemlich alles was ich zu Arrays sagen wollte (der Rest wurde ja schon ausführlich erklärt).

Dann gibt es noch die Records. Ein Record ist eine einfache Struktur. Auch hier liegen die einzelnen Elemente eingentlich nur direkt hintereinander im Speicher. Du findest hier allerdings häufig auch noch Ausrichtungen im Speicher, aber das ist erstmal egal. Anders als beim Array, kann ein Record sich aus unterschiedlichen Datentypen zusammensetzen.
Das Problem an einem Record ist, dass es immer als ganzes durch den Speicher bewegt wird. Möchtest du ein Record an eine Funktion übergeben, so wird hier das komplette Record übergeben. Da sich ein Record aus verschiedenen Datentypen und aus beliebig vielen Variablen zusammensetzen kann, kannst du hier schnell eine relativ große Struktur erzeugen, deren kopieren entsprechend viel Zeit kostet. Deswegen wird in der imperativen Programmierung häufig mit einem Zeiger auf ein Record gearbeitet. Ein Zeiger ist dabei (auf einem 32 Bit System) immer 32 Bit groß. Dies ist völlig unabhängig von der Größe des Records, auf den dieser Zeiger zeigt (Adressen haben diese feste Größe). Wird nun ein solcher Zeiger übergeben, so müssen nur noch 4 Byte kopiert werden (je nach Record kann dies ein deutlich kleinerer Wert als die Recordgröße bedeuten). Bei der Arbeit mit Zeigern gibt es jedoch verschiedene Dinge zu beachten. Auch hier gilt wieder, dass diese unbedingt initialisiert werden müssen. Es kann sonst leicht zu Problemen kommen. Da ein Zeiger nur die Adresse einer Struktur beinhaltet, wird hier nicht mit einer Kopie des referenzierten Datums gearbeitet. Alle Änderungen an dieser Struktur (Belegung des Records) werden direkt im Speicher der Variablen ausgeführt, sind also quasi-global.

Möchte man eine dyn. Anzahl von Records erzeugen, so hat man hier die Auswahl zwischen verschiedenen Möglichkeiten. Hier kommt new in Spiel. New reserviert Speicher für eine bestimmte Struktur. New ist dabei einfach typsicher, man übergibt einen Zeiger auf die Struktur und new alloziert Speicher in der Größe der dereferenzierten Struktur. Dieser Speicher muss später entsprechend wieder frei gegeben werden.
Mit new lassen sich so dyn. Examplere einer Struktur erzeugen. Wie man diese verwaltet ist wiederum beliebig und unabhängig vom new. Man kann hier ein Array von Zeigern verwalten oder eine TList verwenden (die greift intern wiederum auf Arrays zurück) oder eine andere Lösung wählen.
Aber auch zu new gibt es Alternativen. So kann man auch ein dyn. Array vom Typ der Struktur erzeugen. Dabei wird ausreichen Speicher reserviert um n (Länge des Arrays) Exemplare der Struktur direkt aufzunehmen. Hier sorgt das finalize dann dafür, dass der Speicher auch wieder frei gegeben wird.

Zudem kannst du auch direkt Speicher (einer bestimmten Größe) allozieren und beliebig verwenden. Hierauf möchte ich gar nicht mehr näher eingehen, denn Typsicherheit sollte immer genutzt werden, wenn dies möglich ist.

Gruß Der Unwissende

[EWeiss]

@Der_Unwissende

Sehr interessant dein Bericht!
Kenn mich schon mit Arrays aus .. allerdings ist die verwaltung von
arrays unter VB nicht ein so großes problem wie in Delphi.
Hier kommen doch einige Sachen mehr zum Tragen
Zeiger, Records, Pointer .. usw
Da habe ich mich im normalfall unter vb nicht mit beschäftigen müssen.

Deshalb war auch meine bitte . Anfang des Threads mir die verwendung
von Arrays unter Delphi einmal genau zu erläutern.
Habe das geschriebene meines erachtens bisher verstanden

Danke nochmal für die Infos!

gruß