conversion octal binaire

Version imprimable

02/10/2006, 11h03
gilles_bzh

conversion octal binaire

bonjour,

j essaie de créer un programme qui converti un nombre octal en nombre binaire codé sur 16 bits
si par example, l entrée est x=121 (en octal), le programme doit retourner y=0000000001010001.
existe-t-il des functions pour convertir la base octal en binaire et comment faire pour ajouter les 0 devant la conversion afin d obtenir les 16 bits?

merci pour votre aide.
gilles
02/10/2006, 11h20
homeostasie

Bonjour,

Citation:

j essaie de créer un programme qui converti un nombre octal en nombre binaire codé sur 16 bits

Bien tu pourrais toujours nous montrer ton code. ;)
02/10/2006, 11h39
David.Schris

Bonjour,

Pour la conversion octal ==> entier, tu peux par exemple utiliser strtoul() [1].
Pour a conversion entier ==> binaire, tu peux tester les bits de l'entier (en partant du bit de poids fort) et afficher un 0 ou un 1 selon la valeur du bit courant. Pour tester la valeur d'un bit, tu utiliseras probablement l'opérateur "et".

Essaye et montre-nous ce que cela donne.

Cordialement,
DS.

[1] - Le faire sans utiliser cette fonction peut aussi être un bon exercice, donc c'est conseillé d'essayer.

ca semble marcher pas trop mal mais ca m a l air compliqué.
je me demander si il n yavait pas une fonction du genre oct2bin ou un truc comme ca !

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
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
int main(void)
{
   int i,j,k,x;
   int resultat[17];
   k=0;
 
   printf("entrer un octal  :");
   scanf("%o",&i);
 
   j=(int)i;
   printf("\nconversion decimal :%d",j);
 
   while (j!=1)
   {
      if (j%2==0 && j!=2)
      {
         resultat[k]=0;
         k=k+1;
         j=j/2;
      }
      else
      {
         resultat[k]=1;
         k=k+1;
         j=j-1;
      }
   }
 
   for(x=k;x<17;x++)
   {
      resultat[x]=0;
   }
 
   for(x=0;x<17;x++)
   {
      printf("\nresultat:%d",resultat[x]);
   }
 
   getchar();
   return 0;
}

Comme david schris a dit, tu pourrais convertir ton octal en décimal et utiliser une fonction permettant d'afficher sous forme binaire.

En suivant le raisonnement de david qui me semble le mieux, voici un exemple de fonction réalisant cela:

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
#define NB_BITS 16
 
char *conv_binaire(int nombre)
{
         int i = 0;             //Compteur de décalage de bits
         int j = NB_BITS -1;    //Emplacement dans la chaine "binaire", on part de la fin
         char *binaire = malloc(sizeof(char) * (NB_BITS+1));
         binaire[NB_BITS]='\0'; //Caractère de fin de chaîne
 
         while(i < NB_BITS)
         {
                 if ( (nombre >> i) & 1)
                 {
                         binaire[j]='1';
                 }
                 else{
                         binaire[j]='0';
                 }
                 i++;
                 j--; 
          }
 
           return binaire;
}

;)

02/10/2006, 13h52
gilles_bzh

merci bien pour votre aide
je crois pouvoir m en tirer
le code posté dans mon message precedent est en fait faux... il ne marche pas pour tout les cas! (et bizarrement camarche pour x=121 !)

Citation:

le code posté dans mon message precedent est en fait faux... il ne marche pas pour tout les cas! (et bizarrement camarche pour x=121 !)

Juste quelques petites remarques sur ton code précedent:
Code:

1 2 3 4 5 6 7 8 9 int i,j,k,x; int resultat[17]; /*Pourquoi 17 si tu désires afficher sous 16 bits*/ /*Un tableau de int pour coder soit 0 ou soit 1 n'est pas le mieux...Utiliser une chaine de caractères pour stocker et afficher le résultat sera tout aussi bien*/ k=0; printf("entrer un octal :"); /*Penser à purger le buffer de sortie stdout*/ scanf("%o",&i); /*la fonction fgets suivie des fonctions strto'X' sont plus sures que scanf*/ j=(int)i; /*i est déjà déclaré en entier, le cast est inutile*/
Bonne journée

02/10/2006, 20h36
Emmanuel Delahaye

Citation:

Envoyé par gilles_bzh

j essaie de créer un programme qui converti un nombre octal en nombre binaire codé sur 16 bits
si par example, l entrée est x=121 (en octal), le programme doit retourner y=0000000001010001.
existe-t-il des functions pour convertir la base octal en binaire et comment faire pour ajouter les 0 devant la conversion afin d obtenir les 16 bits?

Tu parles de conversion texte vers texte ?

"121" -> "0000000010100001"

Il faut convertir la chaine octale en numérique avec strtoul() et la base 8, puis convertir en texte avec une fonction à écrire toi même.

Rappel : les valeurs sont codées en binaire. Il siffit donc de tester les bits un par un et d'afficher '0' ou '1' en fonction de la valeur du bit.
02/10/2006, 20h42
Emmanuel Delahaye

Citation:

Envoyé par homeostasie

Comme david schris a dit, tu pourrais convertir ton octal en décimal

8O Je ne pense pas que David ai parlé de 'décimal'. (Je rappelle que la représentation interne des valeurs est binaire et non BCD).

finalement j ai pondu ca qui marche a peu pres...

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
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
int expo (int a,int b);
 
int main(void)
{
int i,j,x;
int resultat[16];
int k=16;
 
printf("entrer un octal  :");
scanf("%o",&i);
 
j=(int)i;
printf("\nconversion decimal :%d",j);
 
while (k>=0)
{
      if (expo(2,k)>j)
          {
          resultat[k]=0;
          printf("\n k=%d\t res=%d",expo(2,k),resultat[k]);
          }
      else
          {
          resultat[k]=1;
          printf("\n k=%d\t res=%d",expo(2,k),resultat[k]);
          j=j-expo(2,k);
          }
      k=k-1;
}
 
printf("\n\n");
for(x=15;x>=0;x--)
{
      printf("%d",resultat[x]);
}
getchar();
getchar();
return 0;
}
 
 
int expo (int a,int b)
{
int i=b;
int j=a;
if (b==0) return 1;
while (i>1)
{
 j=j*a;
 i--;
}
return j;
}

en tous cas merci pour votre aide

Citation:

Envoyé par gilles_bzh

finalement j ai pondu ca qui marche a peu pres...

Ton code, bien que la saisie ne soit pas sécurisée, est en effet correct. Cependant, il est un peu 'en vrac', et augure mal de ce que pourrrait être un gros code... Il est difficilement lisible et peu maintenable.

Je te conseille donc une organisation plus modulaire. Garder en tête que la brique d'organisation du code en C est la fonction. Il faut donc en user et en abuser. Pour cela, 2 approches :

La réécriture.
La conception 'de haut en bas' (c'est par là qu'on aurait du commencer !).

1 - La réécriture consiste à réorganiser ton code de façon à en dégager les blocs fonctionnels et les echanges de données. Pour celà, on travaille sur le code en réduisant au minimum la portée des données. Celà fait apparaître des blocs fonctionnels cohérents que l'on peut alors nommer par commentaire. Il ne reste plus ensuite qu'à en faire des fonctions.
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 #include <stdio.h> #include <stdlib.h> #include <math.h> #include <string.h> static int expo (int a, int b) { int j; if (b == 0) { j = 1; } else { j = a; int i = b; while (i > 1) { j = j * a; i--; } } return j; } int main (void) { int i; /* saisie */ { int n; do { printf ("entrer un octal :"); n = scanf ("%o", &i); if (n != 1) { int c; while ((c = getchar()) != '\n') { } } } while (n != 1) ; } { int resultat[16]; /* conversion */ { int j = i; printf ("conversion decimal :%d\n", j); { int k = 16; while (k >= 0) { if (expo (2, k) > j) { resultat[k] = 0; printf (" k=%d\t res=%d\n", expo (2, k), resultat[k]); } else { resultat[k] = 1; printf (" k=%d\t res=%d\n", expo (2, k), resultat[k]); j -= expo (2, k); } k--; } printf ("\n"); } } /* affichage */ { int i; for (i = 15; i >= 0; i--) { printf ("%d", resultat[i]); } } printf ("\n"); } return 0; }
2 - La conception descendante est la méthode 'officielle'. Elle consiste à commencer par décrire le comportement avec des phrases simples et claires. C'est l'algorithme :

Saisir la valeur au format octal
Créer une chaine représentant cette valeur en binaire
Afficher cette chaine

Ensuite, on va écrire le pseudo-code qui permet de créer les fonctions et d'organiser les échanges de données sans entrer dans les détails d'implémentation :
Code:

1 2 3 4 5 6 BEGIN valeur := saisie_au_format_octal() creer_une_chaine_binaire(chaine, valeur) afficher(chaine) END
Maintenant, on peut travailler sur chaque fonction, en se concentrant sur l'essentiel, sans être parasité par le reste. C'est la mise en oeuvre du fameux principe 'Divide and conquer' (diviser pour regner) :
2.1 saisie_au_format_octal()
Algorithme

Afficher une invite de saisie "Entrer une valeur en octal de 0 a 177777"
Saisir une ligne de texte
Convertir la chaine représentant une valeur en octal de 0 à 0xFFFF en numérique
Si la valeur est erronée recommencer en 1

Pseudo-code:
Code:

1 2 3 4 5 6 7 8 9 10 saisie_au_format_octal():INTEGER BEGIN REPEAT afficher_invite("Entrer une valeur en octal de 0 a 177777") saisir_chaine(chaine) erreur := convertir_octal_en_numerique(chaine, valeur) UNTIL NOT erreur RETURN valeur END
2.2
etc.

On va voir qu'on tombe sur du code plus simple, plus compact, testable individuellement, réutilisable... bref, du code industriel.

Dans une approche itérative (méthode dites 'agile'), on ferait tout de suite une maquette pour fixer les idées (c'est à fire, les variables, les paramètres, les types) :
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 /* Pseudo-code de l'application BEGIN . valeur := saisie_au_format_octal() . creer_une_chaine_binaire(chaine, valeur) . afficher(chaine) END */ #include <stdio.h> #define EN_TRAVAUX(s)\ printf ("%s in progress at %s:%d\n", s, __FILE__, __LINE__) /* fonctions privees */ static unsigned saisie_au_format_octal(void) { EN_TRAVAUX("saisie_au_format_octal()"); } static void creer_une_chaine_binaire(char *chaine, size_t size, unsigned valeur) { EN_TRAVAUX("creer_une_chaine_binaire()"); } static void afficher(char const *chaine) { EN_TRAVAUX("afficher()"); } /* fonction publique */ int main (void) { unsigned valeur = saisie_au_format_octal(); char chaine[32]; creer_une_chaine_binaire(chaine, sizeof chaine, valeur); afficher(chaine); return 0; }
Ce qui donne évidemment :
Code:

1 2 3 4 5 6 saisie_au_format_octal() in progress at main.c:20 creer_une_chaine_binaire() in progress at main.c:25 afficher() in progress at main.c:30 Press ENTER to continue.

03/10/2006, 22h40
David.Schris

Citation:

Envoyé par Emmanuel Delahaye

[...] C'est la mise en oeuvre du fameux princie 'Conquer and divide' (diviser pour regner) :[...] les parmètres, les types) : [...]

==> "principe"
==> "Divide and Conquer" (on divise avant de régner)
==> "paramètres"
Ca, c'était rien que pour t'embêter.

Sinon, rien à dire [1].

[1] - Enfin, si : "chapeau bas".
03/10/2006, 22h51
Emmanuel Delahaye

Citation:

Envoyé par David.Schris

==> "principe"
==> "Divide and Conquer" (on divise avant de régner)
==> "paramètres"

OK, correctaid.