L'écriture binaire pour les débutants [Résolu]

[Roland Chastain]

Bonjour!

Je propose une discussion à l'usage des débutants autour de l'écriture binaire.

Il n'est pas mauvais, de temps en temps, de revenir aux choses fondamentales dont on n'a pas toujours une connaissance très distincte. Par exemple, je viens d'apprendre ce que veut dire le mot bit. Je ne le savais pas, et peut-être ne suis-je pas le seul dans ce cas. Ça veut dire binary digit, c'est-à-dire un chiffre binaire.

Dès lors j'ai pu comprendre (enfin je crois) ce que c'était qu'un octet! J'en étais si content que j'en ai fait un programme.

@Paul TOTH

J'ai inséré la modification que tu m'avais montrée, mais je ne suis pas venu à bout de la comprendre. C'est pourquoi j'ai conservé les deux versions de la fonction.

Code :

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
(*--------------------------------------------------------------------------*)
(* Etude à l'usage des débutants:                                           *)
(* Ecriture binaire et écriture décimale                                    *)
(* d'un nombre compris entre 0 et 255,                                      *)
(* pour comprendre ce qu'est un octet.                                      *)
(*--------------------------------------------------------------------------*)
 
program Octet;
uses Crt;
 
type
  TOctetChaine = string[8];
 
(*--------------------------------------------------------------------------*)
(* 1. De l'écriture décimale à l'écriture binaire                           *)
(*--------------------------------------------------------------------------*)
 
function ByteToOctet(b: Byte): TOctetChaine;
  const
    temp: TOctetChaine = '';
  begin
    repeat
      if (b mod 2 = 1)
      then
        temp := '1' + temp
      else
        temp := '0' + temp;
      b := b div 2;
    until b=0;
    ByteToOctet := temp;
  end;
 
(*--------------------------------------------------------------------------*)
(* 2. De l'écriture binaire à l'écriture décimale                           *)
(*--------------------------------------------------------------------------*)
 
(* version longue *)
 
function DeuxPuissance(n: Byte): LongInt;
var
  i: Byte;
  temp: LongInt;
begin
  if n=0 then temp:=1
  else
    begin
      if n=1 then temp:=2
      else
        begin
          temp:=2;
          for i:=2 to n do temp:=2*temp;
        end;
    end;
  DeuxPuissance := temp;
end;
 
function OctetToByte(o: TOctetChaine): Byte;
  var
    i, temp: Byte;
  begin
    temp:=0;
    for i := Length(o) downto 1 do
      begin
        if o[i] = '1' then temp := temp + DeuxPuissance(Length(o)-i);
      end;
    OctetToByte := temp;
  end;
 
(* version courte *)
 
function OctetToByte2(o: TOctetChaine): Byte;
  var
    i, temp: Byte;
  begin
    temp := 0;
    for i := 1 to Length(o) do
      begin
        temp := 2 * temp;
        if o[i] = '1' then
          Inc(temp);
      end;
    OctetToByte2 := temp;
  end;
 
(*--------------------------------------------------------------------------*)
(* Programme principal                                                      *)
(*--------------------------------------------------------------------------*)
 
begin
  TextBackground(Blue);
  ClrScr;
  TextColor(White);
  WriteLn;
  WriteLn('Binaire(77) = ', ByteToOctet(77));
  WriteLn;
  WriteLn('Decimale(''1001101'') = ', OctetToByte('01001101'));
  WriteLn;
  WriteLn('Decimale(''1001101'') = ', OctetToByte2('01001101'));
  ReadKey;
end.

[Paul TOTH]

Alors on va ajouter une petite info

en primaire on apprend les bases, notion qui semble bien obscure à cet âge là et qu'on oublie ensuite pendant longtemps...puis on fait de l'informatique et on nous parle de binaire, décimal, hexadécimal...ça va en Pascal on échappe à l'octal...et tout cela ce n'est rien d'autre que des bases:
binaire = base 2
décimal = base 10
hexadécimal = base 16
octal = base 8

On retrouve aussi dans le codage des mails le codage Base64 qui lui est plus explicite, c'est de la base 64.

Alors c'est quoi une base ? et bien ce sont les "chiffres" qu'on utilise pour écrire un nombre, en base 10 on a "0123456789", pour le 10ième nombre on utilise 2 chiffres "1" et "0". C'est à dire que le "0" implicite devant "09" passe à "1" et le "9" revient à "0"; c'est comme ça qu'on passe de "9" (ou "09") à "10".
Quand on était petit on faisait des paquets de 10 allumettes et des paquets de paquets pour savoir combien on en avait en tout, 1 paquet + 2 allumettes = 12 allumettes

Dans les autres bases on utilise d'autres chiffres

base 2 = "01"
base 10 = "0123456789"
base 16 = "0123456789abcdef"
base 8 = "01234567"
base 64 = "A..Z","a..z","0..9","+/"

et le principe est le même, quand on n'a plus assez de chiffre pour compter un nombre on ajoute le "1" devant et on repasse au "0" (en base 64 c'est B et A)

du coup on peut faire un traitement de conversion d'un nombre dans un base assez facilement (en dehors de la base 64 qui n'utilise pas les chiffres classiques)

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
function IntToBase(i, base: Integer): string;
const
// tous les chiffres de la base 2 à 16
  Digits :array[0..15] of Char = '0123456789ABCDEF';
begin
  Result := '';
  while i > 0 do // tant que le nombre est > 0
  begin
   Result := Digits[i mod base] + Result; // ajouter un chiffre à hauteur de la base
   i := i div base; // diviser par la base
  end;
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
// je reprend ici la notation & pour binaire, $ pour hexa et un préfixe 0 pour l'octal
  ShowMessage(IntToBase(10,10));
  ShowMessage('&&'+IntToBase(10,2));
  ShowMessage('$'+IntToBase(10,16));
  ShowMessage('0'+IntToBase(10,8));
end;

petit exercice pas très compliqué, écrire la fonction BaseToInt qui s'utilise comme ceci et doit afficher 10 à chaque fois

Code :

1
2
3
4
5
6
7
8
9
10
11
12
 
function BaseToInt(const Str: string; Base: Integer): Integer;
begin
  // ???
end;
 
begin
  ShowMessage(IntToStr(BaseToInt('10', 10)));
  ShowMessage(IntToStr(BaseToInt('1010', 2)));
  ShowMessage(IntToStr(BaseToInt('A', 16)));
  ShowMessage(IntToStr(BaseToInt('12', 8)));
end;

NB: dans ma modification de la fonction OctetToByte, je ne fais que multiplier par la base 2 le nombre à chaque itération tout comme on multiplie par 10 un nombre décimal pour lui ajouter des unités. "12" -> 1 * 10 + 2, "123" = "(1 * 10 + 2) * 10 + 3

[Roland Chastain]

Merci pour la leçon et pour l'exercice.

[Roland Chastain]

Voici la fonction IntToBase dans sa version Turbo Pascal.

Code :

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
program Demo_IntToBase; { Turbo Pascal }
uses Crt;
 
function IntToBase(i, base: Integer): string;
const
  { tous les chiffres de la base 2 à 16 }
  Digits: array[0..15] of Char = '0123456789ABCDEF';
var
  Result: string;
begin
  Result:='';
  while i > 0 do { tant que le nombre est plus grand que zéro }
    begin
      { ajouter un chiffre à hauteur de la base }
      Result := Digits [i mod base] + Result;
      { diviser le nombre par la base }
      i := i div base;
    end;
  IntToBase:=Result;
end;
 
begin
  TextBackground(Blue);
  TextColor(White);
  ClrScr;
  WriteLn('Diverses fa‡ons d''‚crire le nombre dix');
  WriteLn('--------------------------------------');
  WriteLn;
  WriteLn('Ecriture d‚cimale     : ', IntToBase(10,10));
  WriteLn('Ecriture binaire      : ', IntToBase(10,2));
  WriteLn('Ecriture hexad‚cimale : ', IntToBase(10,16));
  WriteLn('Ecriture octale       : ', IntToBase(10,8));
  ReadKey;
end.

Maintenant je passe à l'exercice.

[Roland Chastain]

Envoyé par Paul TOTH

petit exercice pas très compliqué, écrire la fonction BaseToInt qui s'utilise comme ceci et doit afficher 10 à chaque fois

Code :

Trouvé, m'sieur !

Code :

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
program Demo_BaseToInt; { Turbo Pascal }
uses Crt;
 
function BaseToInt(const Str: string; Base: Integer): Integer;
const
  Digits: array[0..15] of Char = '0123456789ABCDEF';
var
  i, temp: Integer;
begin
  temp := 0;
  for i := 1 to Length(Str) do
  begin
    temp := Base * temp;
    Inc(temp, Pos(Str[i], Digits) - 1);
  end;
  BaseToInt := temp;
end;
 
begin
  ClrScr;
  WriteLn(BaseToInt('10', 10));
  WriteLn(BaseToInt('1010', 2));
  WriteLn(BaseToInt('A', 16));
  WriteLn(BaseToInt('12', 8));
  ReadKey;
end.

[Paul TOTH]

Parfait

[droggo]

Joe,
[QUOTE=Paul TOTH;6721930]

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
 
function IntToBase(i, base: Integer): string;
const
// tous les chiffres de la base 2 à 16
  Digits :array[0..15] of Char = '0123456789ABCDEF';
begin
  Result := '';
  while i > 0 do // tant que le nombre est > 0
  begin
   Result := Digits[i mod base] + Result; // ajouter un chiffre à hauteur de la base
   i := i div base; // diviser par la base
  end;
end;

Je ne suis pas vraiment d'accord avec cette fonction, car elle oublie tout simplement de gérer les nombres négatifs.

1 - Généralement, pour écrire dans une base autre que 10, on considère que la donnée est un format non signé (donc BYTE, WORD, DWORD... pour Pascal), il faudrait donc un cast si tu gardes l'entête de la fonction.

2 - en base 10, il faudra tenir compte du fait qu'un nombre peut être négatif, et donc ajouter le signe dans la représentation en chaîne.

Je réagis, car en l'état, ta fonction est incapable de montrer la représentation de tout entier < 0, d'où problème manifeste, et qu'il faudra aussi tenir compte de la remarque 1 ci-dessus.

[Paul TOTH]

Remarque judicieuse

j'ai utilisé Integer comme type générique et non pour autoriser les valeurs négatives sinon base aurait été déclaré TBase = 2..16; sous peine d'avoir des résultats inattendus

Ceci dit la notation "-$5" est acceptable, il est donc relativement simple d'introduire le support des négatifs sans passer par la forme $FFFFFFFFFFFFFFFB.

[droggo]

Hie,

Oui, MAIS :

- tu ne tiens pas compte des valeurs négatives pour créer la représentation et tu te prives donc de la moitié des valeurs possibles.

- "-$5" ne sert qu'à entrer une valeur exprimée en hexa. Quid des bases 2 et 8 ?

Bref, je maintiens ma remarque. Un type générique, ok, mais il faut tenir compte de toutes les possibilités, ce qui n'est pas du tout le cas de ta fonction.

Comme apparemment ça sert à notre ami Roland Chastain pour apprendre à gérer les différentes représentations, et que la fonction proposée ne permet pas de représenter les données négatives, qui sont "spéciales" pour les nombres signés, je me demande s'il sait comment ça fonctionne ?

[Roland Chastain]

Dans ma carrière de programmeur du dimanche, je n'ai jamais vu une écriture binaire ou hexadécimale utilisée pour noter un nombre négatif. Donc je n'ai pas cru devoir approfondir le sujet. Mais s'il y a des choses à apprendre, je vous écoute.

Autrement, pour l'en-tête qui ne correspond pas exactement à l'usage de la fonction, je rencontre souvent ce problème, mais j'ai fini par me dire qu'on ne pouvait pas le résoudre rigoureusement. Ou alors il faudrait redéfinir tous les types à chaque fois en fonction des besoins !

Par exemple cette fonction qui calcule les puissances de 2:

Code :

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
program P2; (* puissances de deux *)
uses crt;
 
function deux_puissance(n: byte): longint;
var i: byte; tmp: longint;
begin
  if n=0 then tmp:=1
  else
    begin
      if n=1 then tmp:=2
      else
        begin
          tmp:=2;
          for i:=2 to n do
            tmp:=2*tmp;
        end;
    end;
  deux_puissance:=tmp;
end;
 
var j: byte;
 
begin
  clrscr;
  for j:=0 to 5 do
    writeln(deux_puissance(j));
  repeat until keypressed;
end.

Même avec un résultat de type LongInt, on voit tout de suite qu'il y a des valeurs pour lesquelles le résultat ne sera pas correct, c'est-à-dire qu'il sera supérieur à la limite du type LongInt. Mais que faire pour éviter cela, sinon calculer la valeur maximale de type Byte pour laquelle le résultat est de type LongInt; puis définir un type limité à cette valeur. On n'est pas sorti de l'auberge!

[Paul TOTH]

Ceci dit, LongInt (qui est strictement équivalent à Integer sous Delphi) est un entier signé...ce que ne sera jamais (signé) une puissance de 2

pour ce qui est de la remarque de droggo il faut savoir que pour des entiers sur 32bits:

Code :

1
2
3
4
5
6
7
8
9
10
11
 
  0 = $00000000 // jamais signé
  1 = $00000001
  ...
  32767 = $7FFFFFFF // le plus grand non signé sur 32 bits
  Integer(32768) = -32768 // $80000000 plus grand nombre négatif
  ..
  ...
  Cardinal(-3) = $FFFFFFFD;
  Cardinal(-2) = $FFFFFFFE;
  Cardinal(-1) = $FFFFFFFF; // car "0 - 1" allume tous les bits et donne bien -1

Pour moi il est tout à fait acceptable de considérer le signe quelque soit la base.

"-012" est un nombre négatif en base 8, c'est en fait implicitement la différence "0 - 012".

Mais si on prend la fonction IntToHex(-1, 8) de Delphi (où 8 est le nombre caractères à retourner et non la base) on obtient FFFFFFFF, soit une représentation hexadécimale "non signée".

A mon avis, ce qui joue en faveur de la représentation avec le signe "-" c'est qu'elle est indépendante du nombre de bits. '-$5' reste négatif qu'on le place dans un entier (signé) 16, 32 ou 64 bits, alors que 'FFFFFFFF' sera positif en 64 bits (signés ou pas) et négatif en 32bits signés.

On peut aussi considérer que 'FFFFFFFF' représente -1 car la longueur de la chaîne représente 32bits, mais il est tout de même plus sympa d'écrire "-&1" ou "-$1", que leur équivalent non signé sur 32 ou 64 bits

Autre solution:

Code :

1
2
3
4
 
type
  TBase = 2..16;
function UInt32ToStringWithBaseFrom2To16(i: Cardinal; base: TBase): string;

mais je trouve ça moins pratique

[droggo]

Joe,

Je veux bien que tu utilises les différentes de cette manière, après tout, c'est ton problème.

Mais, quand je regarde mon parcours de programmeur, je n'ai eu besoin de travailler avec des bases autres que 10 que pour 2 cas, toujours parce qu'il est utile de visualiser les bits :

- travailler avec un type qui utilise différents champs de bits dans une même variable (à l'époque, je me suis bien amusé avec le type real de TP)

- travailler sur une variable destinée à positionner des bits sur un port

Dans les deux cas, on se fout complètement de savoir si une valeur se retrouve négative ou pas en fonction des données, et on considère donc toujours qu'on est en non signé (avec ta méthode, ça va modifier les bits si la valeur résultante est négative).

Un seul autre cas est d'utiliser de telles fonctions pour expliquer aux débutants comment on représente les données, base 2 ou 16, qui sont parfaitement équivalentes.
Là encore, ce qui compte, c'est la représentation des bits telle qu'elle est effectivement en mémoire.

Pour Roland Chastain : Si tu veux voir comment on représente les valeurs négatives sur la plupart des processeurs, cherche pour complément à 2.
Ce n'est pas la seule méthode possible, mais ses avantages ont conduit à son usage quasi universel (il doit bien encore exister quelques systèmes qui en utilisent une autre, mais je ne les connais pas).

[Roland Chastain]

Pendant mes insomnies je lis les anciennes discussions du forum. J'y apprends des tas de choses.
Voyez, au sujet des bases numériques, l'excellente notice de droggo.
Cela m'a donné l'idée de faire un programme qui montrerait les étapes du calcul au lieu de donner simplement le résultat.

[droggo]

Koe,

Effectivement, tu es remonté assez loin.

C'est en fait le petit fichier d'explication que je donne aux élèves qui ont "oublié" comment faire une conversion de base (ça revient régulièrement comme exercice, donc au moins quelques élèves par an ).