einer variable eine adresse zuweisen

[c113plpbr]

Ist es möglich einer variable eine andere adresse zuzuweisen? Wenn ja, wie?
Ich will also quasi eine Variable, mit zwei Namen ... hört sich komisch an, macht aber in meinem Fall durchaus sinn ...

ciao & thx, Philipp

[PierreB]

Vielleicht mittels eines Array's ?
Oder du machst einfach 2 Variablen mit gleichem Inhalt.

[c113plpbr]

Zitat:

Zitat von delphman

Vielleicht mittels eines Array's ?

Wie meinst du das? Ich möchte zwei Variablen, die auf die selbe Speicheradresse zugreifen ... ein array passt da nicht

Zitat:

Zitat von delphman

Oder du machst einfach 2 Variablen mit gleichem Inhalt.

Das will ich vermeiden ...

ciao, Philipp

[jfheins]

Vielleicht geht das mit pointern, also einer Variable und einer Variable, die darauf zeigt. dann kannst du über beide den gleichen Inhalt erreichen ...

[PierreB]

Zitat:

Wie meinst du das? Ich möchte zwei Variablen, die auf die selbe Speicheradresse zugreifen ... ein array passt da nicht

Ups, sorry. Ich hatte wohl erst nicht so ganz verstanden was du eigentlich machen willst. ;) Wieso willst du denn nicht einfach 2 Variablen mit gleichem Inhalt nehmen?

[Sprint]

Zitat:

Zitat von c113plpbr

Ich will also quasi eine Variable, mit zwei Namen ... hört sich komisch an, macht aber in meinem Fall durchaus sinn

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  ValueA: Integer;
  ValueB: PInteger;
begin

  ValueB := @ValueA;

  ValueA := 12;
  ShowMessage(IntToStr(ValueB^));

  ValueB^ := 21;
  ShowMessage(IntToStr(ValueA));

end;

[c113plpbr]

Zitat:

Zitat von Sprint

Zitat:

Zitat von c113plpbr

Ich will also quasi eine Variable, mit zwei Namen ... hört sich komisch an, macht aber in meinem Fall durchaus sinn

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  ValueA: Integer;
  ValueB: PInteger;
begin

  ValueB := @ValueA;

  ValueA := 12;
  ShowMessage(IntToStr(ValueB^));

  ValueB^ := 21;
  ShowMessage(IntToStr(ValueA));

end;

Ist mir bekannt, aber ich will sowas wie ValueB^ vermeiden, denn ich denke, dass es doch möglich sein muss einer anderen (in diesem fall) integer-variable die selbe adresse unterzuschieben, ohne dass man einen pointer auf die selbe adresse hat, und diesen dann immer wieder dereferenziert.

[edit]dereferenziert, nicht referenziert ... hrmpf[/edit]

ciao, Philipp

[Sprint]

Zitat:

Zitat von c113plpbr

Ist mir bekannt, aber ich will sowas wie ValueB^ vermeiden, denn ich denke, dass es doch möglich sein muss einer anderen (in diesem fall) integer-variable die selbe adresse unterzuschieben, ohne dass man einen pointer auf die selbe adresse hat, und diesen dann immer wieder dereferenziert.

Delphi-Quellcode:

type
  TForm1 = class(TForm)
  ...
  private
    { Private-Deklarationen }
    FValue: Integer;
  public
    { Public-Deklarationen }
    property ValueA: Integer read FValue write FValue;
    property ValueB: Integer read FValue write FValue;
  end;

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin

  ValueA := 12;
  ShowMessage(IntToStr(ValueB));

end;

[c113plpbr]

@Sprint: Das wäre ne idee ... aber bevor ich sowas mache, nehme ich lieber die pointer-dereferenzier-methode ... ^^

Nun, vielleicht ein paar "erklärungen" zu dieser Problemstellung:
Ich bringe (m)eine DLL in den Speicher einers (fremden) Prozesses, um dort Funktionen aufzurufen, und Variablen zu verändern. Funktionsaufrufe sind relativ einfach, wenn man die Funktionen "deklariert" hat:

Delphi-Quellcode:

var
  ProcABC : procedure(abc : DWORD); stdcall = pointer($01001234);
...

ProcABC(12345);

Nun wäre es natürlich sehr praktisch, wenn es mit Variablen genauso gehen würde. Es geht zwar, über (wie oben genannt) Dereferenzierung von Pointern, aber es wäre natürlich praktisch, wenn man z.B. vorhandenen code, ohne bei jeder variable darauf achten zu müssen ein ^ anzuhängen, kopieren könnte. Außerdem sieht es gleich unkomplizierter aus ... ^^

ciao, Philipp

[Chewie]

Vielleicht hilft dir absolute weiter.

[NicoDE]

Du suchst absolute.

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  Foo: Integer;
  Bar: Integer absolute Foo;
begin
  Foo := 42;
  ShowMessage(IntToStr(Bar));
end;

Ich würde trotzdem den von Sprint gezeigten Weg empfehlen.

[Matze]

Wenn ich sage:

Delphi-Quellcode:

a := 5;
b := a;

Dann verweist doch b auch nur auf die Speicheradresse von a. Zumindest meint dies mein Informatiklehrer, ist das nicht korrekt?

[Oxmyx]

Zitat:

Zitat von Matze

Wenn ich sage:

Delphi-Quellcode:

a := 5;
b := a;

Dann verweist doch b auch nur auf die Speicheradresse von a. Zumindest meint dies mein Informatiklehrer, ist das nicht korrekt?

Nein, das ist falsch. "a" und "b" haben verschiedene Speicheradressen, in denen jeweils der Wert 5 steht. Bei jeder Zuweisung von Variablen wird die komplette Variable kopiert (auch wenn es ein Record ist).

Eine Speicheradresse weist man mit dem Adress-Operator an eine Zeigervariable zu:

Delphi-Quellcode:

var
  a: Integer;
  pa: PInteger;
begin
  a := 5;
  pa := @a;  // pa zeigt auf die Speicheradresse von a
end;

[c113plpbr]

Zitat:

Zitat von Matze

Wenn ich sage:

Delphi-Quellcode:

a := 5;
b := a;

Dann verweist doch b auch nur auf die Speicheradresse von a. Zumindest meint dies mein Informatiklehrer, ist das nicht korrekt?

Wenn das so wäre, würde, wenn du b z.B. den wert 1 übergibst sich doch auch der wert von a ändern, oder? und das tut er nicht ... (zum glück ... :) )

Absolute würde warscheinlich gehen, wenn dies eine variable aus meiner DLL wäre, was aber nicht so ist. Und so wie ich das sehe, kann man mit absolute zwar exakt das tun was ich will, aber nur mit variablen, die in meinem quellcode deklariert sind ... oder geht da etwa was mit adressen?

@Oxmyx: lies mal die anderern posts, und du wirst erfahren, dass ich dereferenzierungen im code vermeiden will, womit mir ein pointer darauf nicht besonders viel weiter hilft.

ciao, Philipp

[Oxmyx]

Zitat:

Zitat von c113plpbr

@Oxmyx: lies mal die anderern posts, und du wirst erfahren, dass ich dereferenzierungen im code vermeiden will, womit mir ein pointer darauf nicht besonders viel weiter hilft.

ciao, Philipp

Ich wollte lediglich die Annahme von Matze korrigieren, dass Zuweisungen keine Kopieroperationen wären.

[stefan2005]

hi,
ich hatte mal gehört, dass man z.B. einer Integer Variable keine neue Addresse zuweisen kann, da ein Integer nicht dynamisch, sondern schon vom Compiler im Code erstellt wird.

Sprich: Der Compiler legt bei der Kompilierung schon 4 Bytes für einen Integer in der EXE Datei an.

ich weiss aber nicht, ob dies auch auf den Delphi Compiler zutrifft und bitte um Berichtigung, wenns nicht stimmt.

cu,
stefan2005

[SirThornberry]

eine neue adresse zuordnen kann man nicht. Deswegen arbeitet man in so einem fall ja auch mit Pointern, "absolute" und/oder propertys

[c113plpbr]

Nagut, dann muss ich mich wohl geschlagen geben ... :|

trotzdem danke für eure ratschläge ... ciao & thx, Philipp

[SirThornberry]

was stört dich an der "absolute" Variante?

[c113plpbr]

Zitat:

Zitat von SirThornberry

was stört dich an der "absolute" Variante?

Es stört mich nichts daran, nur ist sie leider hier nicht möglich, weil die variablen auf die ich zugreife, nicht in meinem Quellcode deklariert sind. Und absolute funktioniert nur bei variablen, die in meinem Quellcode deklariert wurden, und nicht für diese zu denen ich nur einen pointer habe (bzw. eine statische adresse). Ansonsten wäre es perfekt.

ciao, Philipp

[Chewie]

Zitat:

Zitat von c113plpbr

Und absolute funktioniert nur bei variablen, die in meinem Quellcode deklariert wurden, und nicht für diese zu denen ich nur einen pointer habe (bzw. eine statische adresse). Ansonsten wäre es perfekt.

Wenn die Adresse statisch & schon zur Laufzeit bekannt ist, dann geht das auch via absolute.

[c113plpbr]

Zitat:

Zitat von Chewie

Wenn die Adresse statisch & schon zur Laufzeit bekannt ist, dann geht das auch via absolute.

So? Dann sag mal wie ... beide zeilen verursachen den selben fehler:

Delphi-Quellcode:

var
  a : DWORD absolute $01005B24;
  b : DWORD absolute pointer($01005B24);

Compilerausgabe:

[Error] hook.dpr(14): E2088 Variable name expected

ciao, Philipp

[tommie-lie]

Wenn du die Adresse kennst, warum nimmst du dann nicht einen Pointer? Angenommen du willst einen Pointer aus Adresse 12345678 haben, geht das z.B. so:

Delphi-Quellcode:

var
  meineZahl: Integer;
begin
  // die Zahl holen
  meineZahl := PInteger(12345678)^;

  // irgendwas damit machen

  // und zurückschreiben geht auch
  PInteger(12345678)^ := meineZahl;
end;

Da du aber sagtest, daß es nicht in deinem Quellcode ist, schwant mir fürchterliches... Es soll dir gesagt sein, daß du unter WindowsNT nicht ohne weiteres an Speicherbereiche von anderen Prozessen rankommst.

[c113plpbr]

Zitat:

Zitat von tommie-lie

Wenn du die Adresse kennst, warum nimmst du dann nicht einen Pointer? Angenommen du willst einen Pointer aus Adresse 12345678 haben, geht das z.B. so:
(...)
Da du aber sagtest, daß es nicht in deinem Quellcode ist, schwant mir fürchterliches... Es soll dir gesagt sein, daß du unter WindowsNT nicht ohne weiteres an Speicherbereiche von anderen Prozessen rankommst.

Die von dir beschriebene methode kenne ich, und ich habe weiter oben geschrieben, warum ich versuche diese zu vermeiden.
Lies die anderen Posts, dann weist du warum es geht, und dann wirst du auch herausfinden, warum dir nichts "fürchterliches zu schwanen" braucht. Ich habe meinen Code per DLL in einen fremden Prozess injeziert, womit ich auf alle Variablen die das programm beinhaltet _ohne_ probleme zugreifen kann, und zwar genauso wie das programm selbst. Nun, sag mir nicht, dass dies nicht möglich ist, denn es funktioniert. Leider eben nicht so wie ich das gerne hätte, sprich ohne dereferenzierung eines Pointers.

ciao, Philipp

[tommie-lie]

Zitat:

Zitat von c113plpbr

Die von dir beschriebene methode kenne ich, und ich habe weiter oben geschrieben, warum ich versuche diese zu vermeiden.

Oha, erste Seite übersehen und dich mit stefan2005 gleichgesetzt, mein Fehler.

Für den Fall fällt mir aber auch nichts anderes ein als der Pointer, wenn die Variable nicht exportiert wird.

[c113plpbr]

Zitat:

Zitat von tommie-lie

Variable nicht exportiert wird

Wie ist das zu verstehen? Seit wann kann man variablen exportieren? Naja, egal, hat ja nicht wirklich was mit meinem Problem zu tun ...

ciao, Philipp

[Christian Seehase]

Moin Philipp,

wie wär's mit einem varianten Record?

Delphi-Quellcode:

MyValue = record
  case byte of
    0 : (ValueA : DWORD);
    1 : (ValueB : DWORD);
end;

[tommie-lie]

Zitat:

Zitat von c113plpbr

Wie ist das zu verstehen?

Na, Variable exportieren, genauso wie 'ne Funktion:

Delphi-Quellcode:

library MyLibrary;

uses
  SysUtils, Dialogs;

var
  i: Integer;

procedure Something;
begin
  ShowMessage(IntToStr(i));
end;

exports
  Something, i;

begin
end.

Das ganze hat nur den kleinen Haken, daß Delphi (zumindest 6) noch keine Möglichkeit zur Verfügung stellt, syntaktisch eine Variable auch wieder zu importieren, wie es mit Funktionen über das external-Statement möglich ist. Variablen muss man also mit GetProcAddress() aus der geladenen Bibliothek zusammensuchen.

Zitat:

Zitat von c113plpbr

Seit wann kann man variablen exportieren?

Keine Ahnung, mindestens seit Delphi 6.


Aber mit absolute geht es nicht, da du keinen Zugriff auf den fremden Code hast, sonst bräuchtest du ja keine DLL. Ein variantes Record ist aus dem gleichen Grund ebenfalls keine Alternative, genauso wenig wie Properties oder sonstiges "Standard"-Zeug der Syntax. Die IMAGEBASE-Direktive bringt hier auch nichts, auch nicht wenn du die relative Adresse einer lokalen Variable wüsstest. Um auf die Variable zuzugreifen, wie man es normalerweise macht mit Variablen, die dazu gemacht sind, zugegriffen zu werden, müsste sie exportiert sein, damit du sie in deiner DLL aus dem Modul laden kannst. Außer dem Pointer fällt mir absolut nichts ein.
Aber warum willst du denn Pointerdereferenzierung vermeiden? Es ist die normale und direkteste Methode auf eine Speicheradresse zuzugreifen, der erzeugte Assemblercode ist so, wie jeder normale Mensch es auch in Assembler schreiben würde: Adresse laden, Wert in die Speicherzelle schreiben, fertig. Wenn du nicht an das Symbol rankommst, wird das wohl die einzige Möglichkeit sein, aber selbst wenn du den Compilerirgendwie doch dazu überreden kannst, eine Variable nicht in dein Image zu nehmen sondern als variable Referenz an irgendeine Speicheradresse anzusehen, wäre ein Pointer sicherlich noch einfacher als die Suche nach der nicht-dokumentierten Compiler-Funktion und Sprach-Feature. ;-)
Wenn es dir darum geht, daß du im fertigen Code nicht jedes Vorkommen von Foo durch Foo^ ersetzen willst, kannst du ja die Suchen&Ersetzen-Funktion nehmen. Und unübersichtlicher... also jeder Hack ist wahrscheinlich für jeden anderen komplexer als ein Pointer, den man dereferenziert, und ein einzelnes Zeichen am Namen angehängt ist ja nun wirklich nichts, was einen dermaßen verwirrt, daß man laut zu schreien anfängt und die Tapete von den Wänden kratzt.

Edit: Ergännzt.

[c113plpbr]

@tommie-lie: löl, aber wie gesagt, ich habs ja schon aufgegeben ... ^^ ...

ciao, Philipp

[tommie-lie]

Zitat:

Zitat von c113plpbr

@tommie-lie: löl

Was war denn an meinem Post so lustig? :gruebel:

[c113plpbr]

Zitat:

Zitat von tommie-lie

Zitat:

Zitat von c113plpbr

@tommie-lie: löl

Was war denn an meinem Post so lustig? :gruebel:

wie wärs damit:

Zitat:

Zitat von tommie-lie

was einen dermaßen verwirrt, daß man laut zu schreien anfängt und die Tapete von den Wänden kratzt.

ciao, Philipp