Exercice langage C: Conversion binaire - décimal

Nous allons représenter l'écriture d'une valeur en binaire par un tableau, appelé binaire, de 16 booléens. La valeur true représentera 1, la valeur false représentera 0. Le premier élément du tableau correspondra au premier bit sur la droite, le dernier élément au bit sur la gauche.

Par exemple, si binaire[0] vaut true, le premier bit sur la droite vaut 1.

  1. Commencez par recopier le programme suivant:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include 

using namespace std;

int main(int argc, char ** argv)
{
  bool binaire[16];
  int valeur;
  int valeur_apres_2_conversions;

  binaire[0]  = true;   binaire[1]  = false;   binaire[2]  = true;   binaire[3]  = false;
  binaire[4]  = false;  binaire[5]  = true;    binaire[6]  = true;   binaire[7]  = true;
  binaire[8]  = true;   binaire[9]  = false;   binaire[10] = true;   binaire[11] = true;
  binaire[12] = false;  binaire[13] = false;   binaire[14] = false;  binaire[15] = false;

  // ...

  return 0;
}
  1. Ajoutez le code qui affiche le tableau binaire (à l'aide d'une boucle for) sous la forme:



    0000 1101 1110 0101
  2. Remplacez le code qui initialise le tableau binaire par le code qui demande une valeur à l'utilisateur, et remplit le tableau binaire par l'écriture en binaire de la valeur. Rappel: l'écriture binaire est constituée des restes des divisions successives par 2. N'oubliez pas de remplir la partie gauche du tableau avec des 0, ou plutôt des false étant donné notre choix de représentation.

    Vérifiez votre programme. Pour la valeur 254, vous devez obtenir:

    0000 0000 1111 1110
  3. Écrivez maintenant le code qui fait la conversion inverse, c'est-à-dire qui retrouve la valeur décimale du nombre représenté dans le tableau binaire. Affichez cette valeur et vérifiez qu'elle est bien identique à la valeur entrée.
  4. Ajoutez le code qui décale les bits du tableau binaire d'un cran vers la gauche.

    Recopiez le code précédent pour trouver la valeur correspondant au tableau après le décalage et affichez-la. Que constatez-vous ?


  1. Idéalement, il faudrait s'assurer que le nombre entré est plus petit que 216. Ici, on ne le fait pas et si l'utilisateur entre un nombre plus grand, il sera tronqué. 
  2. Pour convertir un nombre binaire en décimal, il suffit d'additionner les puissances de 2 correspondant à chacun des bits.
  3. Lorsqu'on décale les bits d'un tableau de binaires d'un cran vers la gauche, on multiplie le nombre par 2. Un déplacement d'un cran vers la droite correspond à une division entière par 2. On comprendra aisément ce qui se passe, si on applique le même décalage à un nombre en base 10.

    Notez que, lors d'un décalage des bits sur la gauche, les bits les plus à gauche sont perdus, et les nouveaux bits à droite sont égaux à 0. Il ne faut pas remettre au début les bits qui sont sortis du tableau à gauche. La même chose est valable lors d'un décalage à droite.

 

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
#include 

using namespace std;

int main(int argc, char ** argv)
{
  const int nb_bits = 16;
  bool binaire[nb_bits];
  int valeur;
  int valeur_apres_2_conversions;
  int puissance;

  cout << "Entrez un entier: ";
  cin >> valeur;

  // conversion decimal -> binaire
  int v = valeur;
  for (int i=0; i<nb_bits; i++)
    {
      binaire[i] = v % 2 == 1;
      v /= 2;
    }

  // affichage du nombre binaire
  for (int j=nb_bits-1; j>=0; j--)
    {
      cout << binaire[j];
      if (j % 4 == 0) // ajoute un espace chaque 4 bits
        cout << " ";
    }
  cout << endl;

  // conversion inverse
  puissance = 1;
  valeur_apres_2_conversions = 0;
  for (int i=0; i<nb_bits; i++)
    {
      valeur_apres_2_conversions += binaire[i] * puissance;
      puissance *= puissance;
    }

  cout << "Valeur retrouvee: " << valeur_apres_2_conversions << endl;

  // decalage des bits vers la gauche
  for (int i=nb_bits-1; i>0; i--)
    binaire[i] = binaire[i-1];
  binaire[0] = false;

  // affichage du binaire
  for (int j=nb_bits-1; j>=0; j--) 
    {
      cout << binaire[j];
      if (j % 4 == 0) // ajoute un espace chaque 4 bits
        cout << " ";
    }
  cout << endl;

  // conversion inverse
  puissance = 1;
  valeur_apres_2_conversions = 0;
  for (int i=0; i<nb_bits; i++)
    {
      valeur_apres_2_conversions += binaire[i] * puissance;
      puissance *= 2;
    }

  cout << "Valeur apres decalage: " << valeur_apres_2_conversions << endl;

  return 0;
}