RAM-Adresse ermitteln

[lzuser]

Hallo,
ich habe zwei Variablen:

type tZeileZeiger=^string;
var Zeile:tZeileZeiger;
Zahl:integer;

begin
New(Zeile);
//RAM-Adressen, auf die Zeile und Zahl zeigen ???
Ausgabe1Edit.Text:=IntToStr(@Zeile); //funktioniert nicht
Ausgabe2Edit.Text:=IntToStr(@Zahl); //funktioniert nicht
end;

Über ein wenig Nachhilfe würde ich mich freuen.
Vielen Dank.

[theo]

Ist das Absicht, dass du das so kompliziert mit Zeigern machen willst?
Wenn ja, was soll das werden? Sieht ziemlich krank aus, das Ganze...

[mse]

Die Compiler Fehlermeldung dürfte

Code: Alles auswählen

Error: Incompatible type for arg no. 1: Got "Pointer", expected "QWord"

lauten. Also:

Code: Alles auswählen

Ausgabe1Edit.Text:=IntToStr(ptruint(@Zeile));

Es gibt auch noch die Möglichkeit sedezimale Schreibweise zu verwenden:

Code: Alles auswählen

Ausgabe1Edit.Text:=IntToHex(ptruint(@Zeile),8); //oder 16 für 64 bit

[lzuser]

Ist das Absicht, dass du das so kompliziert mit Zeigern machen willst?
Wenn ja, was soll das werden? Sieht ziemlich krank aus, das Ganze...

Danke für den hilfreichen Kommentar.

[theo]

Danke für den hilfreichen Kommentar.

War nicht böse gemeint. Ich denke nur, dass es besser wäre, auch zu beschreiben was man letztlich erreichen will.
S.a.: http://www.tty1.net/smart-questions_de.html#goal" onclick="window.open(this.href);return false;

[lzuser]

Danke für den hilfreichen Kommentar.

War nicht böse gemeint. Ich denke nur, dass es besser wäre, auch zu beschreiben was man letztlich erreichen will.
OK, dann frage ich dich auch gleich nochmal:
(Eine an mse abgeschickte Nachfrage kam irgendwie nicht an ???)

Ich möchte für eine Demo die Adressen im Stack und im Heap ermitteln.
Mein jetziger Stand:

type tZeileZeiger=^string;
var Zeile1,Zeile2:tZeileZeiger;

Folgende Befehle:

Code: Alles auswählen

//RAM-Adressen ermitteln:
MeldungenMemo.Lines.Add
  ('Zeile1 hat die RAM(Stack)-Adresse: '+IntToStr(ptruint(@Zeile1)));
MeldungenMemo.Lines.Add
  ('Zeile2 hat die RAM(Stack)-Adresse: '+IntToStr(ptruint(@Zeile2)));
MeldungenMemo.Lines.Add
  ('Zeile1 enthält als Zeiger die RAM(Heap)-Adresse: '+IntToStr(ptruint(Zeile1)));
MeldungenMemo.Lines.Add
  ('Zeile2 enthält als Zeiger die RAM(Heap)-Adresse: '+IntToStr(ptruint(Zeile2)));

ergeben:
ohne New(Zeile1) und New(Zeile2)
Zeile1 hat die RAM(Stack)-Adresse: 5786236
Zeile2 hat die RAM(Stack)-Adresse: 5786240
Zeile1 enthält als Zeiger die RAM(Heap)-Adresse: 0 (entspricht wohl NIL)
Zeile2 enthält als Zeiger die RAM(Heap)-Adresse: 0

nach New
Zeile1 hat die RAM(Stack)-Adresse: 5786236
Zeile2 hat die RAM(Stack)-Adresse: 5786240 (ist klar, weil ein Pointer 4byte belegt)
Zeile1 enthält als Zeiger die RAM(Heap)-Adresse: 450264
Zeile2 enthält als Zeiger die RAM(Heap)-Adresse: 450312 (ist noch nicht klar: 1 String=48byte????)

[mse]

nach New
Zeile1 hat die RAM(Stack)-Adresse: 5786236
Zeile2 hat die RAM(Stack)-Adresse: 5786240 (ist klar, weil ein Pointer 4byte belegt)
Zeile1 enthält als Zeiger die RAM(Heap)-Adresse: 450264
Zeile2 enthält als Zeiger die RAM(Heap)-Adresse: 450312 (ist noch nicht klar: 1 String=48byte????)

new() bezieht Speicher vom memorymanager, wo der Block angelegt wird ist Sache des memorymangers und schwierig vorauszusehen.

[Socke]

Wenn du den Heap überwachen willst, solltest du dir einen eigenen Memory-Manger schreiben. Der bekommt immer mit, wenn Speicher angefordert oder freigegeben wird (du kannst einfach alles auf den alten MM durch reichen).

So, nun zu deinem Code:
Verwende doch bitte die Code-Tags, ist einfacher zu lesen.
Die Ausgabe von Speicheradressen wird üblicherweise in Hex ausgegeben, da dann alle gleich lang sind.
String ist bereits ein Zeiger und ein Zeiger auf einen Zeiger wird nur benötigt, wenn man einen Zeiger zurückgeben will (bspw. Callback/var-Parameter).
Wo die Strings im Heap abgelegt werden, sollte nicht dich sondern nur den Memory-Manager interessieren. Die 48 Byte Unterschied in der Adresse sind deshalb völlig in Ordnung (auch wenn mir nicht klar ist, was du mit einem Zeiger auf einen String bezwecken willst).

Sonstiges:
Sowohl Heap als auch Stack liegen im RAM. Wenn du das Wort "RAM" aus der Ausgabe entfernst, könnte das einfacher zu lesen sein.
Nach New() solltest du immer Dispose() aufrufen; sonst hast du Speicherleichen.

[mschnell]

tZeileZeiger=^string;

Ich glaube nicht, dass ein Zeiger auf einen String das ist, was Du willst. Vermutlich willst Du ja einen Zeiger auf die Zeichen in einem String. Das ist ein pchar.

var p: pchar;
...

p:=pchar(mystring);

Vorsicht ! String ist "reference counted". wenn mystring jetzt "out of fokus" gerät, zeigt p auf nichts mehr.

pchar(mystring) ist dasselbe wie @mystring[1], aber nicht dasselbe wie @mystring !

-Michael

[lzuser]

Wenn du den Heap überwachen willst, solltest du dir einen eigenen Memory-Manger schreiben. Der bekommt immer mit, wenn Speicher angefordert oder freigegeben wird (du kannst einfach alles auf den alten MM durch reichen).

Das war nicht meine Absicht. Ich wollte nur eine Demo der Speicheradressen.

Die Ausgabe von Speicheradressen wird üblicherweise in Hex ausgegeben, da dann alle gleich lang sind.

Das stimmt aber nicht bei meinen Ausgaben, oder?

String ist bereits ein Zeiger und ein Zeiger auf einen Zeiger wird nur benötigt, wenn man einen Zeiger zurückgeben will (bspw. Callback/var-Parameter).

Ich hätte auch einen Zeiger auf irgend einen umfangreichen Adressdaten-Record nehmen können, war mir nur zu umständlich.

Wo die Strings im Heap abgelegt werden, sollte nicht dich sondern nur den Memory-Manager interessieren.

Das tut es aber nun mal.

Die 48 Byte Unterschied in der Adresse sind deshalb völlig in Ordnung.

Und genau dafür brauche ich noch eine Begründung: Warum liegen die beiden String-Speicher nur 48 Byte
auseinander, ich kann doch einen längeren String ohne Problem speichern und wieder lesen.
Wie macht das der Memory-Manger?

Nach New() solltest du immer Dispose() aufrufen; sonst hast du Speicherleichen..

Klar!

[Socke]

Um die Zahlen als Hexadezimal-String zu formatieren musst du statt IntToStr die Funktion IntToHex aufrufen.
Wie der Heap funktioniert, steht irgendwo in den Dokumentationen. Ich weiß nur noch, dass er intern wie ein Stack aufgebaut ist. Wenn du wissen willst, was genau gemacht wird, musst du den memory-Manger direkt befragen. Der Standard-Manager ist in der Datei rtl/inc/heap.inc der FPC-Quellen.

[theo]

Und genau dafür brauche ich noch eine Begründung: Warum liegen die beiden String-Speicher nur 48 Byte
auseinander, ich kann doch einen längeren String ohne Problem speichern und wieder lesen.
Wie macht das der Memory-Manger?

Die AnsiStrings habe ja keine fixe Länge. Das hängt von deren Inhalt ab.

[mschnell]

Und genau dafür brauche ich noch eine Begründung: Warum liegen die beiden String-Speicher nur 48 Byte
auseinander, ich kann doch einen längeren String ohne Problem speichern und wieder lesen.

Der eigentliche "String" ist eine Struktur, die aus Referenzzähler, Länge und Pointer auf die Zeichenkette besteht 3*4 = 12 Bytes, die restlichen 36 Bytes sind andere Variablen, die auf dem Heap angelegt wurden, und/oder Overhead des Memory-Managers.

Der Pointer in der String-Struktur enthält die Adresse, die Du mit @MyString[1] oder pchar(MyString) bekommst. Beim Schreiben von Strings wird dieser Pointer u.U. verändert und der Speicher, auf den verwiesen wird unabhängig auf dem Heap dynamisch verwaltet.

Wenn Du übrigens

MyString1 := 'Hallo';
MyString2 := MyString1;

Machst, zeigen die Pointer beider Strings auf dieselbe Speicherstelle und 'Hallo' wird nur einmal auf dem Heap angelegt. Machst Du nun

MyString2[2] := 'x';

passiert ein "lazy copy".

-Michael

[mse]

Wie der Heap funktioniert, steht irgendwo in den Dokumentationen. Ich weiß nur noch, dass er intern wie ein Stack aufgebaut ist.

Nicht mehr, das war zu Turbo Pascal Zeiten. Da war der Heap ein zusammenhängender Block Ram der mit mark() und release() manipuliert werden konnte. Heute kann der Heap aus vielen, nicht zusammenhängenden Blöcken bestehen.

Die 48 Byte Unterschied in der Adresse sind deshalb völlig in Ordnung.

Und genau dafür brauche ich noch eine Begründung: Warum liegen die beiden String-Speicher nur 48 Byte
auseinander, ich kann doch einen längeren String ohne Problem speichern und wieder lesen.
Wie macht das der Memory-Manger?

Falls dein Testprogramm so aussieht:

Code: Alles auswählen

type 
 tZeileZeiger=^string;
var 
 Zeile1,Zeile2:tZeileZeiger;
begin
 [...]
 new(Zeile1);
 new(Zeile2);
 [...]

wird durch new(Zeile1) ein Speicherbereich des Typ tZeileZeiger^ = string reserviert und gegebenenfalls initialisiert. string = AnsiString im {$h+} Modus. Die Speichergrösse einer AnsiString-Variable ist die Grösse eines Pointers = 4 Byte in 32 Bit, siehe auch die Ausführungen vom mschnell. Nach new(Zeile1) sollte Pointer(Zeile1^) den Wert NIL zeigen, da referenzgezählte Variablen (AnsiString, WideString, dynamisches Array) mit null initialisiert werden.
Wie bereits mehrmals erwähnt, kann nicht davon ausgegangen werden, dass new() den Speicher in zusammenhängenden Bereichen anlegt. Fall du den Speicherbedarf einer Variable oder eines Typen wissen möchtest, benutze sizeof(). sizeof(zeile1^) liefert 4 auf 32Bit.