Pointer, Arbeitsspeicher etc..

[Neutral General]

Hi,

Ich wollte den String auslesen der an einer bestimmten Speicheradresse liegt.

So

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var Hallo: Pointer;
    bla: String;
begin
Instanz := TKlasse.Create;
Instanz.Eigenschaft := 'Hallo';
Hallo := GetMemory($00403EB0); // an der Adresse müsste Instanz.Eingeschaft sein
SetLength(bla,sizeof(Integer));
bla := String(@Hallo);
ListBox1.Items.Add(bla);
end;

Da kommt jedoch nur kryptische Zeichen xD
Ist GetMemory dafür überhaupt geeignet ?
Und ich habe die Adresse herausgefunden indem ich z.B Caption := Instanz.Eigenschaft geschrieben habe bevor die Klasse erstellt wurde. Die Adresse von der Zugriffsverletzung hab ich dann genommen. Bin mir aber auch nicht sicher ob das so geht

Ach ja noch was wodrauf ich gestoßen bin, was ich sehr komisch fand:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var Hallo: Pointer;
    bla: String;
begin
Instanz := TKlasse.Create;
Instanz.Eigenschaft := 'Hallo';
Hallo := GetMemory($00403EB0); // Da müsste 'Hallo' gespeichert sein
Form1.Font.Name := (String(@Hallo)); 
SetLength(bla,sizeof(Integer));
ListBox1.Items.Add(bla);
end;

Das ist eine seltsame Erscheinung finde ich. Also wenn ich das so da stehen hab steht in der Listbox "comc"
Aber woher kommt das ? Ich hab Bla doch gar nix zugewiesen^^
Wenn ich schreibe

Caption := (String(@Hallo)); dann steht in der ListBox "Form".. komisch.
Vielleicht auch nur komisch weil ich von Pointern mal (fast) keine Ahnung hab

[Luckie]

GetMemory alloziiert dir nur Speicher, wie auch ein Blick in die Hilfe es dir gesagt hätte. Aber warum nutzt du nicht eine Methode / Property der Klasse, um dir den Wert zurückgeben zu lassen?

[Neutral General]

Das war eigentlich nur ein Ansatz um ein Programm zu schreiben, das den ganzen Arbeitsspeicher auslesen soll.. Wenn das überhaupt geht..

[Flocke]

Schreibe nicht
Hallo := GetMemory($00403EB0); sondern einfach
Hallo := pointer($00403EB0); (einfacher Typecast)

[Neutral General]

Zitat von Flocke:

Schreibe nicht
Hallo := GetMemory($00403EB0); sondern einfach
Hallo := pointer($00403EB0); (einfacher Typecast)

Ok und wie bekomme ich das dann in Klartext ausgegeben ?

[Neutral General]

*PUSH*

Also die Sache würde mich schon interessieren

[tigerman33]

Dann empfehle ich dir einen Blick in die Hilfe, zum Thema typisierte Zeiger und Dereferenzierung.

[Neutral General]

Mh.. Also zu typisierte Zeiger hab ich nichts gefunden und das was bei Dereferenzierung steht bringt mich irgendwie auch nicht weiter

[tigerman33]

Donnerwetter, da findet die Hilfe tatsächlich nichts!!

Ein typisierter Zeiger ist ein Zeiger, der den Typ der Daten, auf die er verweist "kennt". Also z.B. ein Zeiger auf einen String, oder auf einen Integer. Deklariert wird das als
type TPInteger = ^integer; Im Gegensatz dazu gibt es untypisierte Zeiger. Diesen Typ nennt man dann pointer.

Dereferenzieren bedeutet dass man die Daten erhalten will, auf die der Zeiger verweist. (Ein normaler Zugriff auf einen Zeiger liefert ja nicht dessen "Wert", sondern seine Speicheradresse!) Dereferenzieren kann man nur typisierte Zeiger (pointer muss man erst typecasten) denn nur diese wissen ja auf was sie eigentlich zeigen.

[Muetze1]

Pointer: untypirisierter Zeiger, da es ein Zeiger ist (klar), aber ohne Angabe auf was er zeigt. Daher: der Typ auf den er zeigt ist unbestimmt. Somit kann man nicht ermitteln wie gross der Speicherbereich sein müsste um ein Element da abzulegen wo er hinzeigt.

Delphi-Quellcode:

Type
  TRGBQuad = Record
    rgbRed: Byte;
    rgbGreen: Byte;
    rgbBlue: Byte;
    rgbReserved: Byte;
  End;
  PRGBQuad = ^TRGBQuad;

PRGBQuad: typirisierter Zeiger, da es ein Zeiger auf eine Struktur vom Typ TRGBQuad handelt. Man weiss wie wo gross der Bereich ist, da man weiss wie gross die Struktur ist.

Delphi-Quellcode:

Var
  lMyPtr : PRGBQuad;  // reserviert mir nur automatisch 4 Bytes um den Zeiger abzulegen - also da wo die Adresse von der Struktur später reinkommt. 
Begin
    // bisher zeigt lMyPtr auf nix - bzw. ins Datennirwana (lokale Variable: sprich uninitialisiert) 
    // es fehlt noch Speicherplatz für die Struktur, also erstmal alloziieren
  New(lMyPtr);
    // New() kann nur mit typirisierten Zeigern ohne weitere Angaben umgehen, da New() die Grösse zu reservierenden Speicher
    // ermitteln muss - und das geht nur mit typirisierten Zeigertypen.
   
  lMyPtr^.rgbRed := 124;   // hier dereferenziere ich 
    // mit anderen Worten: ich will ja nicht auf den Zeiger zugreifen sondern auf den Speicherbereich auf den lMyPtr zeigt,
    // und dort dann ganz speziell auf den rgbRed Wert der Struktur - diese liegt ja in dem Bereich. Der Typ bringt 
    // sozusagen Ordnung da rein und gibt mir die Möglichkeit bequem auf bestimmte Offsets innerhalb des Speicherbereichs zu 
    // zu greifen. Und um nun zu sagen ich will nicht auf den Zeiger (lMyPtr) zugreifen sondern auf das, wo er hinzeigt, 
    // dereferenziere ich ihn mit dem ^. (Nach dem Motto: sag mir nicht wo, sondern bring mich hin!)

    // so, auch in Beispielen sauber bleiben, also Speicher wieder freigeben den wir uns mit New() geholt hatten
  Dispose(lMyPtr)
End;

Einen untypirisierten Zeiger kann man mit dem ^ genauso dereferenzieren, aber da ist dann das Problem, das er (der Compiler) beim Zugriff nicht weiss, was nun alles zu dem Bereich gehört wo er hinzeigt. Das kann ein Byte, ein Array, eine Struktur oder sonstwas sein, daher meckert er im Normalfall - er weiss nicht damit umzugehen durch den fehlenden Typ. Du kannst ihm einen Typ zuweisen in dem du ihm sagst, das er auf ein Byte zeigt. Bsp:

Delphi-Quellcode:

Var
  lMyPtr : Pointer;
Begin
  GetMem(lMyPtr, 4); // 4 bytes reservieren und den Zeiger auf diese 4 Bytes zeigen lassen.
  lMyPtr^ := 22;    // Tja, wie gross ist der Datentyp??? Worauf zeigt er? Der Compiler streikt hier...
  PByte(lMyPtr)^ := 22; // so weiss er den Typ und weiss nun, es ist ein Byte gross und kann entsprechend zuweisen.

  FreeMem(lMyPtr, 4);
End;