Discussion :

[Zaki_SDwin]

Salut a tous, comment ouvrir un fichier dans son code binaire sur un composant Memo ou Richedit avec seulement le 0 et le 1, c'est très important pour moi, et surtout un grand MERCI d'avance.
Parce que j'ai un exemple que j'ai télécharger mais ça marche pas, le programme ouvre n'importe quel type de fichiers sur un Memo mais dans un code trop bizarre, ni hexadécimal ni ASCII voici l'exemple :

LIRE-FICHIER-BINAIRE.zip

[Aka Guymelef]

Bonsoir,

voici une petite fonction que je viens de finir de coder spécialement pour toi qui transforme le contenu d'un fichier en sa représentation binaire :

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
44
45
46
function FileToStrBit( const FileName: String ): String;
const
 Convert: array['0'..'F'] of String =
  ('0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001',
   '', '', '', '', '', '', '', // caractères superflus du tableau, cf table ASCII
   '1010', '1011', '1100', '1101', '1110', '1111'
  );
var
 AStream: TMemoryStream;
 Buffer, Buffer2: PChar;
 Cpt: Integer;
begin
  Result := '';
  AStream := TMemoryStream.Create;
  try
   // charger le fichier
   AStream.LoadFromFile( FileName );
 
   // allouer le buffer de lecture du fichier
   GetMem( Buffer, AStream.Size );
   // allouer le buffer de récupération du fichier au format HexaDecimal
   // la taille doit être le double que la taille du fichier (chaque octet du fichier
   // fait deux lettres hexadecimal) +1 pour inclure le #0 de fin de chaîne
   GetMem( Buffer2, AStream.Size * 2 + 1 );
   try
    // récupérer les octets du fichier
    AStream.Seek( 0, soFromBeginning );
    AStream.ReadBuffer( Buffer^, AStream.Size );
 
    // transformer les octets en leur représentation hexadécimal dans une chaîne
    BinToHex( Buffer, Buffer2, AStream.Size );
 
    // remplacer chaque caractère Hexadécimal par sa représentation binaire dans le chaîne résultat
    for Cpt := 0 to ( AStream.Size * 2 - 1 ) do
     Result := Result + Convert[Buffer2[Cpt]];
 
   finally
    FreeMem( Buffer );
    FreeMem( Buffer2 );
   end;
 
  finally
   AStream.Free;
  end;
 
end;

Sous réserve de bug éventuels mais normalement ça devrait être bon.

[Zaki_SDwin]

Aka Guymelef merci beaucoup ça fonctionne très bien, c'est trop gentil de ta part d'avoir créer ce code spécialement pour moi, je vais bien étudier le code pour pouvoir enregistrer le fichier modifier en binaire.

Voici un code à rajouter :

Code :

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

Form1.Caption:='Aka Guymelef est le meilleur';

[Aka Guymelef]

C'est trop d'honneur

Mais non je ne suis pas le meilleur, il n'y a qu'à regarder la panoplie de tutoriels présents sur le site pour s'en rendre compte. De plus tu remarqueras que je fais une double conversion (binaire -> StrHexa -> StrBinaire) tout simplement parce que je n'ai pas trouvé de manière la plus concise et la plus jolie de faire. Reste néanmoins que c'est pas forcement le plus optimisé mais ça permet de voir également comment on pourrait obtenir le binaire en StrHexa.

[ShaiLeTroll]

je fais une double conversion (binaire -> StrHexa -> StrBinaire) tout simplement parce que je n'ai pas trouvé de manière la plus concise et la plus jolie de faire.

Suffisait de demander

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
44
45
46
function FileToStrBit(const FileName: string): string;
  const
    BitStringForHalfByte: array[0..15] of String =
     ('0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001',
      '1010', '1011', '1100', '1101', '1110', '1111'
     );
  var
    AStream: TFileStream;
    Readed, StreamSize: Int64;
    PResult: PChar;
    Buffer: array[Word] of Byte;
    I, AmtTransferred: Integer;
    B: Byte;
  begin
    AStream := TFileStream.Create(FileName, fmOpenRead);
    try
      StreamSize := AStream.Size;
      if StreamSize > 0 then
      begin
        SetLength(Result, StreamSize * 8);
        PResult := @Result[1];
 
        AStream.Seek(0, soFromBeginning);
        Readed := 0;
        while Readed < StreamSize do
        begin
          AmtTransferred := AStream.Read(Buffer, SizeOf(Buffer));
          Inc(Readed, AmtTransferred);
 
          for I := 0 to AmtTransferred - 1 do
          begin
            B := Buffer[I] shr 4;
            CopyMemory(PResult, @BitStringForHalfByte[B][1], 4);
            Inc(PResult, 4);
            B := Buffer[I] and $0F;
            CopyMemory(PResult, @BitStringForHalfByte[B][1], 4);
            Inc(PResult, 4);
          end;
        end;
      end
      else
        Result := '';
    finally
     AStream.Free;
    end;
  end;

[Zaki_SDwin]

Merci a vous, Mais ajouter des commentaires sur les lignes changées ça aide beaucoup à comprendre pour les débutants comme moi.

[Aka Guymelef]

Quand je le disais qu'il y avait des meilleurs que moi.

Bon je tente de commenter mais à vérifier par ShaiLeTroll, ça tombe très bien parce que je ne suis pas très fort en manipulation de pointeur et de données binaires donc c'est un bon exercice.

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
function FileToStrBit(const FileName: string): string;
  const
    // représentation des valeurs hexadécimal en binaire chaîne
    BitStringForHalfByte: array[0..15] of String =
     ('0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001',
      '1010', '1011', '1100', '1101', '1110', '1111'
     );
  var
    AStream: TFileStream;
    Readed, StreamSize: Int64;
    PResult: PChar;
    Buffer: array[Word] of Byte;
    I, AmtTransferred: Integer;
    B: Byte;
  begin
    // ouverture du fichier
    AStream := TFileStream.Create(FileName, fmOpenRead);
    try
      StreamSize := AStream.Size;
      if StreamSize > 0 then
      begin
        // allouer la chaîne finale qui doit faire 8 fois la taille du fichier
        // en effet StreamSize indique le nombre d'octet du fichier et un octet
        // fait 8 caractères pour être représenté sous forme de chaîne
        SetLength(Result, StreamSize * 8);
        // obtenir un pointeur sur la chaîne
        PResult := @Result[1];
 
        // partir du début
        AStream.Seek(0, soFromBeginning);
        Readed := 0;
        while Readed < StreamSize do
        begin
          // array[Word] of Byte est équivalent à écrire array[0..65535] of Byte
          // on lit 65536 octets du fichier
          AmtTransferred := AStream.Read(Buffer, SizeOf(Buffer));
          Inc(Readed, AmtTransferred);
 
          // pour chaque octet récupéré par la lecture dans le buffer
          for I := 0 to AmtTransferred - 1 do
          begin
            // un octets c'est 8 bits soit xxxx xxxx
            // un caractère hexadécimal équivaut à 4 bits, donc un octet s'écrit avec deux caractères hexadécimaux
 
            // récupérer la valeur (de 0 à 15) des 4 premiers bits de l'octet en cours soit le premier caractère héxadécimal
            B := Buffer[i] shr 4;
            // @BitStringForHalfByte[b] donne alors la chaîne représentant le premier caractère hexa et @BitStringForHalfByte[b][1] donne un pointeur sur cette chaîne
            // Copier donc la représentation binaire du premier caractère hexa dans la chaîne finale
            CopyMemory(PResult, @BitStringForHalfByte[b][1], 4);
            // déplacer le curseur courant sur la chaîne finale de 4 pour qu'il reste à la fin de la chaîne
            // les ajouts avec CopyMemory se font donc toujours à la fin comme ça
            Inc(PResult, 4);
            // récupérer la valeur (de 0 à 15) des 4 derniers bits de l'octet en cours soit le second caractère héxadécimal
            B := Buffer[i] and $0F;
            // @BitStringForHalfByte[b] donne alors la chaîne représentant le second caractère hexa et @BitStringForHalfByte[b][1] donne un pointeur sur cette chaîne
            // Copier donc la représentation binaire du secondcaractère hexa dans la chaîne finale
            CopyMemory(PResult, @BitStringForHalfByte[b][1], 4);
            // déplacer le curseur courant sur la chaîne finale de 4 pour qu'il reste à la fin de la chaîne
            // les ajouts avec CopyMemory se font donc toujours à la fin comme ça
            Inc(PResult, 4);
          end;
        end;
      end
      else
        Result := '';
    finally
     AStream.Free;
    end;
  end;

[Zaki_SDwin]

C'est plus claire maintenant, Thanks

[ShaiLeTroll]

Bon je tente de commenter mais à vérifier par ShaiLeTroll, ...

Cela me semble très bien commenté, en général, je ne commente pas les codes, laissant cela à celui qui prend le code, si il est consciencieux, il va le commenter ou du moins essayer et demander conseil, si il est de plus généreux, il va en faire partager tout le monde, dans les autres cas, il copiera bêtement sens réfléchir et c'est bien dommage ...

@Zaki_SDwin, la version originale de ton message de 12h50 était bien plus cinglante ...