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:

Zitat von Der schöne Günther (Beitrag 1359344)

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 :stupid:

...:cat:...

[Der schöne Günther]

Also so wie ich es verstehe wird bei

Delphi-Quellcode:

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

Delphi-Quellcode:

var

in

Delphi-Quellcode:

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

Delphi-Quellcode:

[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. :stupid:

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].