BlockRead

Question

Salut a tous
je vous en suppppppplie aider moi avec block read voila ma fonction qui me donne erreur e/s 998 :
Function Readhexa(Fichier:string;offeset:string):string;
Var
  E4    : File;
  E3    : Char;
  I     : LongInt;
  a    :integer;
Begin
   AssignFile(E4, fichier);
    Reset(E4,1);

  Blockread(E4,E3,aa);
  result:=inttostr(aa);
  If FileSize(E4)<>Files then
  begin
     MessageDlg('Erreur dans le fichier!.',mtError,[mbOk],0);
  end;
End;

Cirec · Answer

Salut,
essaye comme &#231;a j'ai un peut &#233;pur&#233; le code :

Function Readhexa(Fichier:string):string;
Var
  E4    : File;
  E3    : array[0..255] of Char;
  I, aa : Integer;
Begin
   AssignFile(E4, fichier);
   Try
    Reset(E4,1);
    Blockread(E4,E3,SizeOf(E3), aa);
  Finally
    CloseFile(E4);
  End;
  result:=  Format('%d Caract&#232;re(s) Lu ', [aa]);
   For  I : = 0 to 255 do
  Result := Result + E3[I];
End;

si tu as encore des questions n'h&#233;site pas

@+
Cirec

dxh_master · Answer

en fet sa va lire tout le fichier?
et jaimerait juste lire un byt! avec son offeset!

jlen100 · Answer

salut

utilises seek(offset) pour placer le pointeur sur l'octet &#224; lire puis tu fais blockread(E4;E3,1)



tu peux aussi declarer E3:string[1]; et dans ce cas l'octet sera en E3[1];

@+

jlen

dxh_master · Answer

j aimerait comprendre ce block :
Try
    Reset(E4,1);
    Blockread(E4,E3,SizeOf(E3), aa);
  Finally
    CloseFile(E4);
  End;
 result:= Format('%d Caractère(s) Lu ', [aa]);
  For I := 0 to 255 do
  Result := Result + E3[I];

en fet tout la fonctio :D

Cirec · Answer

Salut,

je vais essayer de t'expliquer ce qui se passe 
dans cette Fonction :

Function Readhexa(Fichier:string):string;
Var
  E4    : File;
  E3    : array[0..255] of Char;
  I, aa : Integer;
Begin
   AssignFile(E4, fichier); // on assigne le nom du fichier &#224; la variable E4
   Try
    Reset(E4,1); // on ouvre le fichier en lecture et on place le curseur sur le premier caract&#232;re &#224; lire
    Blockread(E4,E3,SizeOf(E3), aa);  // on lit un block de 256 caract&#232;res (SizeOf(E3) =  256) et aa renvoie le nombre
    // de caract&#232;res &#233;ffectivement lu
   Finally 
    CloseFile(E4); // et on referme le Fichier
  End;  result: Format('%d Caract&#232;re(s) Lu ', [aa]);  // si aa est  &#224; 128 par Ex.  :  Result sera = &#224; '128 Caract&#232;re(s) Lu '
   For  I : = 0 to aa do // aa &#233;tant plus juste que 255
// et on ajoute ce que l'on a pr&#233;c&#233;dement lu caract&#232;re par caract&#232;re &#224; Result
  Result := Result + E3[I];
End;

est ce que c'est suffisement claire comme &#231;a 

@+
Cirec

dxh_master · Answer

je sais pas a  quoi cela sert : 

   Try
     ...
  Finally
     ...
  End;

jlen100 · Answer

try finaly sert &#224; la gestion des exceptions: si une des instruction
situ&#233;es entre try et finaly ne peut &#234;tre ex&#233;cut&#233;  (fichier absent
par exemple) on passe directement &#224; l'instruction situ&#233;e apr&#232;s finaly
sans "plant&#233;" le programme

voici en plus d&#233;taill&#233; ce que dit l'aide DELPHI:

"

Dans certains cas, il est indispensable que
certaines parties d'une op&#233;ration s'effectuent, que l'op&#233;ration soit ou
non interrompue par une exception. Si, par exemple, une routine prend
le contr&#244;le d'une ressource, il est souvent important que cette
ressource soit lib&#233;r&#233;e quelle que soit la mani&#232;re dont la routine
s'ach&#232;ve. Vous pouvez, dans ce genre de situations, utiliser une
instruction try...finally.



L'exemple suivant illustre comment du code qui ouvre et traite un
fichier peut garantir que le fichier est ferm&#233;, m&#234;me s'il y a une
erreur &#224; l'ex&#233;cution.



Reset(F);

try

 ...  // traiter le fichier F

finally

  CloseFile(F);

end;



Une instruction try...finally a la syntaxe suivante :



try listeInstructions1 finally listeInstructions2 end



o&#249; chaque listeInstructions est une suite d'instructions d&#233;limit&#233;es par
des points-virgule. L'instruction try...finally ex&#233;cute les
instructions de listeInstructions1 (la clause try). Si
listeInstructions1 se termine sans d&#233;clencher d'exception, 
listeInstructions2 (la clause finally) est ex&#233;cut&#233;e. Si une exception
est d&#233;clench&#233;e lors de l'ex&#233;cution de listeInstructions1, le contr&#244;le
est transf&#233;r&#233; &#224; listeInstructions2 ; quand listeInstructions2 a fini de
s'ex&#233;cuter, l'exception est red&#233;clench&#233;e. Si un appel des proc&#233;dures
Exit, Break ou Continue force la sortie de listeInstructions1,
listeInstructions2 est ex&#233;cut&#233;e automatiquement. Ainsi, la clause
finally est toujours ex&#233;cut&#233;e quelle que soit la mani&#232;re dont se
termine l'ex&#233;cution de la clause try.



Si une exception est d&#233;clench&#233;e sans &#234;tre g&#233;r&#233;e par la clause finally,
cette exception se propage hors de l'instruction try...finally et toute
exception d&#233;j&#224; d&#233;clench&#233;e dans la clause try est perdue. La clause
finally doit donc g&#233;rer toutes les exceptions d&#233;clench&#233;es localement
afin de ne pas perturber la propagation des autres exceptions.

"

@+

jlen

BlockRead

7 réponses

Votre réponse

Discussions similaires