Dll-Methodenparameter von var nach const ändern

[Der schöne Günther]

Eine ganz dumme Frage, ich bin in Sachen DLL-Interop nicht so fit.

Ich habe eine Methode

Delphi-Quellcode:

procedure stuff(
   var   a:   Integer;
   var   b:   Integer;
   var   c:   Integer
); stdcall;

Kann ich sie (Parameter "b") gefahrlos ändern in

Delphi-Quellcode:

procedure stuff(
   var   a:   Integer;
   const   b:   Integer;
   var   c:   Integer
); stdcall;

Und alles bleibt untereinander kompatibel?

[sakura]

Zitat von Der schöne Günther:

Kann ich sie (Parameter "b") gefahrlos ändern in

Ich denke eher nicht, als var-Parameter wird die Adresse der Variable übergeben, als const der eigentliche Wert - zumindest für Integer Variablen sollte es gerade so sein Aber Du kannst es ja mal testen

......

[Der schöne Günther]

Also so wie ich es verstehe wird bei const der Parameter entweder per Referenz oder per Wert übergeben (siehe StackOverflow)

Mir geht es darum dass eine Routine einen var-Parameter hat, aber es unerwünscht ist dass dieser verändert wird. Um in Zukunft zu verhindern dass die implementierende Delphi-DLL den Wert eines Tages anfassen wird soll der Parameter von var in const geändert werden.

[jaenicke]

Das kannst du doch leicht testen. Einfach eine Methode so, die andere so und dann sieht das Ergebnis so aus:

Delphi-Quellcode:

procedure stuffA(var a: Integer); stdcall;
procedure stuffB(const a: Integer); stdcall;

Unit155.pas.40: stuffA(a);
005C9AF3 8D45F8           lea eax,[ebp-$08]
005C9AF6 50               push eax
005C9AF7 E8D4FFFFFF       call stuffA
Unit155.pas.41: stuffB(a);
005C9AFC 8B45F8           mov eax,[ebp-$08]
005C9AFF 50               push eax
005C9B00 E8D3FFFFFF       call stuffB

Sprich bei var wird die Adresse übergeben (lea - load effective address), bei const der Wert (mov - Wert herüberschieben).

[hoika]

Hallo,

Zitat:

Um in Zukunft zu verhindern dass die implementierende Delphi-DLL den Wert eines Tages anfassen wird soll der Parameter von var in const geändert werden.

Wer implementiert denn die DLL?
Wenn das Methoden-Interface nicht mehr geändert werden kann,
dann rette einfach den Wert vor dem DLL-Aufruf und schreibe ihn danach wieder zurück.

[Der schöne Günther]

Ok danke, mit Assembler kenne ich mich kein Stück aus. Das bedeutet also nein.

Ich verstehe das mit dem Assembler aber noch nicht, wenn ich jetzt z.B. einmal gerne dasd [Ref] testen würde.

Folgender Code

Delphi-Quellcode:

program Project16;

{$APPTYPE CONSOLE}

{$R *.res}

uses System.SysUtils;

var
   a,b,c: Integer;

procedure stuffA(
   var   a:   Integer;
   var   b:   Integer;
   var   c:   Integer
 ); stdcall;
 begin
    asm nop end;
 end;

 procedure stuffB(
   var   a:   Integer;
   const [Ref]  b:   Integer;
   var   c:   Integer
 ); stdcall;
 begin
    // b := 42; // VERBOTEN
    asm nop end;
 end;

begin
   a := 10;
   b := 20;
   c := 30;

   stuffA(a,b,c);
   stuffB(a,b,c);
end.

ergibt folgende Assembly:

Code:

Project16.dpr.31: begin
004194E8 55               push ebp
004194E9 8BEC             mov ebp,esp
004194EB 83C4F0           add esp,-$10
004194EE A164B64100       mov eax,[$0041b664]
004194F3 C60001           mov byte ptr [eax],$01
004194F6 B8806E4100       mov eax,$00416e80
004194FB E89CF6FEFF       call @InitExe
Project16.dpr.32: a := 10;
00419500 C705C80E42000A000000 mov [$00420ec8],$0000000a
Project16.dpr.33: b := 20;
0041950A C705CC0E420014000000 mov [$00420ecc],$00000014
Project16.dpr.34: c := 30;
00419514 C705D00E42001E000000 mov [$00420ed0],$0000001e
Project16.dpr.36: stuffA(a,b,c);
0041951E 68D00E4200       push $00420ed0
00419523 68CC0E4200       push $00420ecc
00419528 68C80E4200       push $00420ec8
0041952D E83AD9FFFF       call stuffA
Project16.dpr.37: stuffB(a,b,c);
00419532 68D00E4200       push $00420ed0
00419537 68CC0E4200       push $00420ecc
0041953C 68C80E4200       push $00420ec8
00419541 E82ED9FFFF       call stuffB
Project16.dpr.38: end.
00419546 E831C7FEFF       call @Halt0

Das bedeutet nun dass man "const [Ref]" als Ersatz für "var" nehmen könnte?

[Fritzew]

Zitat:

Das bedeutet nun dass man "const [Ref]" als Ersatz für "var" nehmen könnte?

Ja genau dafür ist [REF] gedacht.

[himitsu]

Selbst wenn der Integer als CONST-Referenz übergeben würde, kann man den Wert dennoch ändern, denn den Pointer hat man dann und ignoriert einfach das CONST.

VAR und OUT sind immer Referenzen.
CONST sagt nur dem Compiler, dass es nicht verändert werden soll, aber nichts darüber, ob als Referenz oder Wert.
CONST und IN/OHNE arbeiten also gleich und bei CONST wird nur eine Compilerprüfung aktiviert, welche man böswillig umgehen könnte.

Bei IN/OHNE ist endweder nur der lokale Wert änderbar, oder es wird ein COPY bei Prozedureintritt, bzw. später als Copy-On-Write implementiert.

Achtung, wenn ein älterer Compiler das [Ref] noch nicht kennt, aber Attribute schon implementiert sind, dann ignoriert er das einfach und gibt nichtmal eine Warnung raus.
Genauso wie bei [Weak] und [Unsave].