Addresse eines var Parameters ermitteln

[TurboMagic]

Hallo,

nix falsche Aufrufkonvention. Die Nutzer haben tatsächlich mit NULL aufgerufen.
Mit der von Uwe angegebenen Format-String Ausgabe kann ich das bestimmt auch
im Log nachweisen, aber es wurde jetzt auch drüber gesprochen diesen Parameter
optional zu machen, was bedeutet, dass ich rausbekommen muss, ob der NULL ist.

Mit Assigned geht es nicht. Es wäre evtl. die Option diese Formatstring Ausgabe
abzuprüfen, da müsste ja für NULL dann '0x00000000' zurückkommen.

Da es die DLL per4spektivisch auch in 64 bit geben wird müsste ich zusätzlich
auch auf '0x0000000000000000' prüfen.

Oder gibt's nicht doch eine bessere Alternative?
Möglichst eine, bei der ich die Deklaration dieses Var-Parameters nicht
abändern muss.

Grüße
TurboMagic

[jaenicke]

Du kannst doch einfach einen Pointer daraus machen. Das ist im Hintergrund auch nichts anderes und so wird es in anderen Sprachen ja bei der Übersetzung ohnehin deklariert (weshalb dann dort auch null übergeben werden kann).

Wenn du die Adresse mit @ abfragst, sollte die aber auch nil sein.

// EDIT:

Delphi-Quellcode:

procedure Test(var a: Int32);
begin
  ShowMessage(IntToHex(NativeUInt(@a), 8) + ' - ' + BoolToStr(Assigned(@a), True));
end;

type
  PInt32 = ^Int32;

procedure TestA(a: PInt32);
asm
  call Test;
end;

procedure ExecTest;
var
  b: Integer;
begin
  b := 42;
  Test(b);
  TestA(@b);
  TestA(nil);
end;

[TiGü]

Zitat von TurboMagic:

Oder gibt's nicht doch eine bessere Alternative?
Möglichst eine, bei der ich die Deklaration dieses Var-Parameters nicht
abändern muss.

Mach aus

function DeineFunktion(var AParameter: UInt32): TRückgabewert;
vernünftigerweise sowas:
function DeineFunktion(AParameter: PUInt32): TRückgabewert;

So kannst du in deiner Funktion prüfen:

Delphi-Quellcode:

function DeineFunktion(AParameter: PUInt32): TRückgabewert; 
begin
  if AParameter <> nil then
  begin
  // ...
  end;
end;

EDIT: Siehe auch jaenickes Beitrag über meinen.

[TurboMagic]

Hallo,

danke für die Antworten. Das einfache

if not (@MyParam = nil) then compiliert und sollte es tun.

Grüße
TurboMagic

[himitsu]

Klar sollte Assigned natürlich auf NIL (C-isch als NULL) prüfen kommen.
Oder meinst das Variant-NULL?

Assigned macht ja auch nur <>nil.
Einzige Ausnahme sind Methoden-Zeiger, wo es zwei nil gibt.



Und was ist denn nun null?
* der Inhalt der Variable
* oder haben sie bösartig die Adresse zur Variable gelöscht?

Letzteres dürfte dir aber egal sein, da es außerhalb keine Wirkung hat und die veränderte Adresse des VAR-Parameters nur innerhalb deren Funktion besteht. (die wird ja quasi dennoch als CONST und None-Reference übergeben ... außer du hast einen Zeiger auf einen Zeiger auf die eigentliche Speicherstelle )

[TurboMagic]

Die haben als Parameter eine NIL Adresse übergeben.
Damit muss es knallen, wenn ich drauf schreibe.

[himitsu]

Ach du bekommst die Adresse.
Klang so, als gibst du denen den Parameter (so callback-mäßig) und der irgendwie als NIL zurück kommt.


Ja, in Delphi ist es etwas "umständlich", wenn man einem VAR-Parameter ein NIL reingeben will. (bei denen wurde es dann wohl einfach als Pointer deklariert)

Delphi-Quellcode:

// entspricht einem procedure Test(A, B: PInteger);
procedure Test(var A: Integer; B: PInteger);
begin
  if not Assigned(B) then
    Beep;
  if not Assigned(@A) then
    Beep;
end;

procedure TForm25.FormCreate(Sender: TObject);
var
  X: PInteger;
begin
  X := nil;
  Test(X^, nil);

  Test(PInteger(nil)^, nil);
end;

tja, Optional geht dann wohl nur

Delphi-Quellcode:

procedure Test(A: PInteger=nil);

// oder
procedure Test(); overload;
procedure Test(var A: Integer); overload;

Ich glaub Emba sagt dazu procedure Test(var [optional] A: Integer); , procedure Test(var A: Integer=0); oder eigentlich eher (aber Vorhergehendes wäre besser) procedure Test(var A: Integer=nil); bestimmt nein.