Paramètre sous forme de constante non typée

**Alcatîz** · 17/06/2006, 13h25

Bonjour à toutes et tous !

Je butte sur le passage de paramètres sous forme de constantes non typées à une procédure ou à une fonction.
Pour prendre un exemple : le paramètre Buffer de la fonction API WriteFile :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
function WriteFile (FileHandle: THandle; const Buffer;
                    NumberOfBytesToWrite: DWord; var NumberOfBytesWritten: DWord; 
                    Overlapped: POverlapped): Bool;

Voici un bête programme d'essai :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
Program ESSAI;
 
Uses Strings, WinCRT, Windows;
 
Var HandleFichier : tHandle;
    NomFichier : Array [0..MAX_PATH] of Char;
 
Function CREATION_FICHIER (NomF : pChar; var HandleF : tHandle) : LongBool;
Begin
  HandleF := CreateFile(NomF,GENERIC_WRITE,FILE_SHARE_WRITE,Nil,
                        CREATE_ALWAYS,FILE_ATTRIBUTE_ARCHIVE,0);
  CREATION_FICHIER := (HandleF <> INVALID_HANDLE_VALUE);
End;
 
Function ECRITURE_FICHIER (HandleF : tHandle; Chaine : pChar) : LongBool;
Var NbBytesEcrits : DWord;
Begin
  ECRITURE_FICHIER := WriteFile(HandleF,Chaine,StrLen(Chaine),NbBytesEcrits,Nil);
End;
 
Function FERMETURE_FICHIER (HandleF : tHandle) : LongBool;
Begin
  FERMETURE_FICHIER := CloseHandle(HandleF);
End;
 
Begin
  InitWinCRT;
  StrCopy(NomFichier,'H:\Essai.txt');
  if CREATION_FICHIER(NomFichier,HandleFichier)
     then
       begin
         if not ECRITURE_FICHIER(HandleFichier,'Blabla')
            then
              WriteBuf('Erreur '#233'criture',15);
         if not FERMETURE_FICHIER(HandleFichier)
            then
              WriteBuf('Erreur fermeture',16);
       end
     else
       WriteBuf('Erreur cr'#233'ation',15);
  ReadKey;
  DoneWinCRT;     
End.

Dans la fonction ECRITURE_FICHIER, je passe un tableau de caractères comme paramètre. Dans le fichier résultat, il y a bien 6 caractères écrits mais... 6 caractères quelconques au lieu de 'Blabla'.

Voici un extrait de l'output Assembleur :

Code asm :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
		ALIGN DWORD
 
ESSAI@ECRITURE_FICHIER PROC NEAR
;
; Function ECRITURE_FICHIER (HandleF : tHandle; Chaine : pChar) : LongBool;
; Var NbBytesEcrits : DWord;
; Begin
;
		PUSH	EBP
		MOV	EBP,ESP
		SUB	ESP,8
	      @@?0:
;
;   ECRITURE_FICHIER := WriteFile(HandleF,Chaine,StrLen(Chaine),NbBytesEcrits,Nil);
;
		PUSH	0
		LEA	EAX,[EBP-8]
		PUSH	EAX
		PUSH	DWORD PTR [EBP+8]
		CALL	Strings@StrLen
		PUSH	EAX
		LEA	EAX,[EBP+8]
		PUSH	EAX
		PUSH	DWORD PTR [EBP+0Ch]
		CALL	WriteFile
;
; End;
;
		MOV	ESP,EBP
		POP	EBP
		RET	8
ESSAI@ECRITURE_FICHIER ENDP

Par contre, lorsque j'utilise un tableau de caractères local à la fonction ECRITURE_FICHIER, c'est bien 'Blabla' qui est écrit dans le fichier résultat.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Function ECRITURE_FICHIER (HandleF : tHandle; Chaine : pChar) : LongBool;
Var NbBytesEcrits : DWord;
    ChaineLocale : Array [0..7] of Char;
Begin
  StrCopy(ChaineLocale,Chaine);
  ECRITURE_FICHIER := WriteFile(HandleF,ChaineLocale,StrLen(ChaineLocale),NbBytesEcrits,Nil);
End;

Output Assembleur :

Code asm :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
		ALIGN DWORD
 
ESSAI@ECRITURE_FICHIER PROC NEAR
;
; Function ECRITURE_FICHIER (HandleF : tHandle; Chaine : pChar) : LongBool;
; Var NbBytesEcrits : DWord;
;     ChaineLocale : Array [0..7] of Char;
; Begin
;
		PUSH	EBP
		MOV	EBP,ESP
		SUB	ESP,10h
	      @@?0:
;
;   StrCopy(ChaineLocale,Chaine);
;
		LEA	EAX,[EBP-10h]
		PUSH	EAX
		PUSH	DWORD PTR [EBP+8]
		CALL	Strings@StrCopy
;
;   ECRITURE_FICHIER := WriteFile(HandleF,ChaineLocale,StrLen(ChaineLocale),NbBytesEcrits,Nil);
;
		PUSH	0
		LEA	EAX,[EBP-8]
		PUSH	EAX
		LEA	EAX,[EBP-10h]
		PUSH	EAX
		CALL	Strings@StrLen
		PUSH	EAX
		LEA	EAX,[EBP-10h]
		PUSH	EAX
		PUSH	DWORD PTR [EBP+0Ch]
		CALL	WriteFile
;
; End;
;
		MOV	ESP,EBP
		POP	EBP
		RET	8
ESSAI@ECRITURE_FICHIER ENDP

Ma question : quelqu'un pourrait-il m'aider à comprendre la différence entre les deux ?

Envoyé par Référence Virtual Pascal

Constant parameters
When a formal parameter is a constant parameter, it can be used like a local read-only variable in the
procedure or function. The corresponding actual parameter substitutes the constant parameter when
the function is called. The actual parameter must be an expression and the result of the expression
cannot be of file type or any structured type containing a file type. The actual parameter must be
assignment-compatible with the type of the formal parameter. A constant formal parameter can not be
assigned values, or be passed as an actual variable parameter to another procedure or function.
Constant parameters are passed in the same way as value parameters. However, when a value needs to
be copied to the local stack of the routine, constant parameters are not copied as the compiler makes
sure the variable is not written to. For this reason, it is better to use a constant formal parameter
instead of a value formal parameter, if a formal parameter has the same value during the execution of
a procedure or function. This protects it against accidental assignments and also lets the compiler
generate more efficient code.

Merci d'avance !

**M.Dlb** · 17/06/2006, 13h42

Salut mon cher !

A priori, je verrais une histoire de pointeurs, de pile et de tas. Peut-être que l'utilisation de const oblige à chercher dans la pile, alors que dans ton premier cas, ta chaîne est dans le tas. On peut imaginer qu'il cherche l'adresse de ta chaîne dans la pile au lieu du tas, ce qui fait pointer sur un endroit non défini, d'où les caractères bizarres que tu obtiens... Mais ca semble très bizarre !

**Eric Sigoillot** · 17/06/2006, 14h35

Hello !

Ah ah, rien de bizarre là dedans

C'est bien simple : dans ton deuxième exemple, tu passes à ta fonction un tableau de caractères (array of Char). Résultat des courses, c'est bien le tableau de caractères qui est écrit.

Mais dans le premier exemple, tu passes une chaîne PChar, définie comme un pointeur vers un tableau de caractères. Résultat des courses, c'est la valeur du pointeur qui est écrite. Logique.
Si tu vérifies, tu pourras constater que les 4 permiers caractères que tu retrouves dans ton fichier correspondent à l'adresse contenue dans ton PChar, et que les 2 restants sont issus de la mémoire (non prévisible facilement).

Si tu veux que ça marche, essaie donc ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
function ECRITURE_FICHIER(HandleF: THandle; Chaine: PChar): LongBool;
var
  NbBytesEcrits: DWord;
begin
  ECRITURE_FICHIER :=  WriteFile(HandleF, Chaine^, StrLen(Chaine), NbBytesEcrits, nil);
end;

Tu noteras que j'ai déréférencé le pointeur Chaine

@++

**Alcatîz** · 18/06/2006, 08h13

Bonjour,

Envoyé par Eric Sigoillot

Tu noteras que j'ai déréférencé le pointeur Chaine

Comment n'y ai-je pas pensé ? Je crois que c'est l'output Assembleur qui m'a troublé l'esprit.

Merci mille fois Eric (et merci à Wormful pour t'être penché sur la question !)

Paramètre sous forme de constante non typée [Virtual Pascal]

Autres IDE Pascal

Discussions similaires

Partager

Partager