Discussion :

[sandball22]

Bonjour,

comment fait-on pour convertir les flottants en binaire et vis versa.

[josse95]

Qu'entends tu par là ?

Veux tu connaitre la représentation binaire interne des flottants, ou veux tu convertir un flottant en int (par exemple) ?

[sandball22]

convertir un flottant en binaire.

[Emmanuel Delahaye]

convertir un flottant en binaire.

Ca n'a aucun sens. Sur une machine 'binaire', toute valeur a une représentation numérique binaire en mémoire. C'est requis par le langage C, qui ne sait pas fonctionner sur des machines autres que binaires.

[Mat.M]

Bonjour,
comment fait-on pour convertir les flottants en binaire et vis versa.

ce genre de question c'est comme comment convertir un type donné en hexadécimal.
Comme le dit Emmanuel et pour la milliardième de fois l'hexa et le binaire sont des représentations.
Il faut que tu te débrouilles avec les masques binaires &= et au besoin les décalages.
Pour info avec printf tu peux formater en octal ou en hexadécimal mais pas en binaire

[Emmanuel Delahaye]

Pour info avec printf tu peux formater en octal ou en hexadécimal mais pas en binaire

... mais uniquement des entiers convertis en non signés, pas des flottants. Il me semble (mais j'ai peut être rêvé) que C99 a un format de printf() pour montrer un flottant en hexadécimal...

[Melem]

comment fait-on pour convertir les flottants en binaire et vis versa.

Dans un ordinateur, tout est représenté en binaire. Si c'est donc pour afficher la représentation d'un flottant en simple précision dans la machine :

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
#include <stdio.h>
 
union U
{
    float x;
    unsigned long n;
}
 
int main(void)
{
    union U u;
 
    u.x = 3.14;
    printf("La representation du nombre %f dans la machine est : %x\n", u.n);
 
    return 0;
}

Ce programme n'a de sens donc que sur une architecture où la taille d'un entier long (c'est-à-dire le nombre d'octets utilisé pour représenter un entier long) est égale à la taile d'un flottant en simple précision, autrement dit si sizeof(float) == sizeof(long), ce qui doit être normalement le cas si t'es assez chanceux .

Le programme affiche la représentation du nombre 3.14 dans l'ordinateur en hexa. S'il n'y a rien d'autre que le binaire qui puisse faire ton bonheur, tu doispasser par ltoa() (stdlib.h).

[Emmanuel Delahaye]

S'il n'y a rien d'autre que le binaire qui puisse faire ton bonheur, tu dois passer par ltoa().

Pas plus portable que la solution exposée (union)...

[Melem]

Pas plus portable que la solution exposée (union)...

Absolument d'accord.

Ce programme n'a de sens donc que sur une architecture où la taille d'un entier long (c'est-à-dire le nombre d'octets utilisé pour représenter un entier long) est égale à la taile d'un flottant en simple précision

Quant à ltoa(), c'est même pas standard en effet.

[sandball22]

Ce que je veux en fait, c'est pourvoir convertir 200 en binaire. et vis versa.

Par exemple, 4 en binaire c'est 100. Voila mon problème

[Melem]

Ce que je veux en fait, c'est pourvoir convertir 200 en binaire. et vis versa.

Mais fallait le dire plutôt!!!

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
#include <stdio.h>
 
int main(void)
{
    int n, N;
    char s[255];
    int i;
 
    N = sizeof(int)*8; //Nombre de bits utilisé pour représenter un entier
 
    printf("Entrer un entier");
    scanf ("%d", &n);
 
    s[N - 1] = (n&1) + '0';
 
    for(i = 2 ; i <= N ; i++)
        s[N - i] = ((n>>=1)&1) + '0';
 
    s[N] = '\0';
 
    printf("En binaire : %s", n, s);
 
    return 0;
}

Tu peux aussi utiliser itoa() ou ltoa() si tu veux mais ces fonctions ne sont pas standards.

Edit :
Avant (Erroné) :

Code :

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

1
2
3
s[N - 1] = (N&1) + '0';
...
s[N - i] = ((N>>=1)&1) + '0';

Après edit :

Code :

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

1
2
3
s[N - 1] = (n&1) + '0';
...
s[N - i] = ((n>>=1)&1) + '0';

J'ai également remarqué qu'il vaut mieux, à l'intérieur de la boucle, déplacer le masque (le 1) plutôt que de décaler n comme ce qui est le cas car on perd alors sa valeur originale. On peut bien sur sauvegarder d'abord cette valeur avant d'entrer dans la boucle mais ...

[sandball22]

Tans que j'y suis j'ai un problème pour afficher un entier si je tape 4 au clavier cela mets -1 ou ds chiffres bidon d'ou sa vient?
Merci.

[scriptoff]

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
#include <stdio.h>
 
int main(void)
{
    int n, N;
    char s[255];
    int i;
 
    N = sizeof(int)*8; //Nombre de bits utilisé pour représenter un entier
 
    printf("Entrer un entier");
    scanf ("%d", &n);
 
    s[N - 1] = (N&1) + '0';
 
    for(i = 2 ; i <= N ; i++)
        s[N - i] = ((N>>=1)&1) + '0';
 
    s[N] = '\0';
 
    printf("%d en binaire : %s", n, s);
 
    return 0;
}

teste ton code avant de poster

Code :

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

1
2
3
4
s[N - 1] = (n&1) + '0';
...
s[N - i] = ((n >>= 1) & 1) + '0';

voila que je propose a l'aide du code de Melem

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
 
#include <stdio.h>
int main(void)
{
    int n, N;
    char s[255];
    int i;
    N = sizeof(int) * 8;
    int fini = 0;
    int ret=0;
 
    while (!fini) {
	printf("Entrer un entier:");
	ret = scanf("%d", &n);
	if (ret == 1)
	    fini = 1;
	else {
	    scanf("%*[^\n]");
	    getchar();
 
	}
    }
 
    s[N - 1] = (n & 1) + '0';
    for (i = 2; i <= N; i++)
	s[N - i] = ((n >>= 1) & 1) + '0';
    s[N] = '\0';
    printf("%d en binaire : %s\n", n, s);
    return 0;
}

[koala01]

Salut,

Convertir un nombre en binaire, en informatique, cela n'a pas de sens...

Pour la simple et bonne raison que TOUT dans l'ordinateur n'est qu'une succession de 0 et de 1 (donc, d'office binaire )

Si ta question est: je voudrais pouvoir avoir la représentation graphique de 200 en binaire, alors, là, c'est autre chose...

L'une des solutions consiste à ce moment là à:

Créer une chaine de caractères
Tester l'ensemble des bits de la valeur et mettre le caractère '0' ou '1' à la position du bit en conséquence

Cela pourrait prendre la forme du code

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
int val=200;
/* il nous faut 8 caractère pour chaque octets
   comme cette taille sera souvent utilisée, autant s'en souvenir */
int i;
int taille=sizeof(int)*8;
/* à l'allocation, il faut prévoir la place pour le '\0' */
char *result=malloc(taille+1);
if(result!=NULL)
{
    /* finissons la chaine pour éviter les problèmes d'affichages*/
    result[taille]='\0';
    /* parcourrons l'ensemble des bits */
    for(i=0;i<taille;i++)
    {
        /* on parcourre les bits de droite à gauche, il faut en tenir compte
           lorsqu'on place les caractères
           on utilise l'opérateur ET binaire pour tester la valeur des bits 
           ;)*/
        result[taille-(i+1)]=(val& 1<<i)? '1':'0';
        /* revient au meme que
        if(val& 1<<i)
            result[taille-(i+1)]='1';
        else
            result[taille-(i+1)]='0';
        */
    }
    printf("%s",result);
    free(result);
    result=NULL;
    return 0;
}
return EXIT_FAILURE;

NOTA:

• Tu remarqueras que j'utilises de préférence un tableau de caractères alloué dynamiquement...
  
  C'est pour l'unique raison qu'il est dangeureux de faire la moindre hypothèse concernant la taille utilisée par un entier dans la mémoire.
  
  S'il est vrai que sur PC, et tant qu'on en reste aux processeurs "non 64 bits" et qu'on utilise un compilateur récent, on peut estimer qu'un entier est codé sur 32 bits, certains compilos "anté déluviens" codaient les entiers sur ... 16 bits à peine, et je n'ai jamais eu l'occasion de tester personnellement la taille d'un entier sur les architectures 64 bits
• Il est, de meme, dangeureux de partir de l'hypothèse qu'un char fasse 8 bits... cela peut etre facilement testé avec le code suivant, qui peut très bien servir à déterminer le multiplicateur fournis à sizeof()
  

  Code :

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

  1
  2
  3
  4
  5
  6
  7
  8
   
  int taillechar=0;
  do
  {
      taillechar++;
      a=1<<taillechar;
  }while(a!=0);
  printf("%d\n",taillechar);

• ces codes fonctionneront sans problèmes sur PC et sur architectures "petit boutistes" (littleendian), mais je ne sais pas du tout ce qu'il en sera pour les architecture bigendian ou middleendian... Si quelqu'un pouvait me renseigner sur le sujet

[Thierry Chappuis]

Dans un ordinateur, tout est représenté en binaire. Si c'est donc pour afficher la représentation d'un flottant en simple précision dans la machine :

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
#include <stdio.h>
 
union U
{
    float x;
    unsigned long n;
}
 
int main(void)
{
    union U u;
 
    u.x = 3.14;
    printf("La representation du nombre %f dans la machine est : %x\n", u.n);
 
    return 0;
}

Ce programme n'a de sens donc que sur une architecture où la taille d'un entier long (c'est-à-dire le nombre d'octets utilisé pour représenter un entier long) est égale à la taile d'un flottant en simple précision, autrement dit si sizeof(float) == sizeof(long), ce qui doit être normalement le cas si t'es assez chanceux .

Le programme affiche la représentation du nombre 3.14 dans l'ordinateur en hexa. S'il n'y a rien d'autre que le binaire qui puisse faire ton bonheur, tu doispasser par ltoa() (stdlib.h).

Le problème de portabilité avec ton programme n'a pas lieu uniquement au niveau de la taille d'un unsigned long int par rapport à un float. Selon la norme, on ne peut accéder à la valeur d'une union de manière portable qu'en utilisant le champ ayant servi à son initialisation. Il y a une exception si l'union contient des structures avec une séquence initiale commune, mais c'est la seule, et ce n'est pas le cas dans ton programme.

Thierry

[Thierry Chappuis]

Il est, de meme, dangeureux de partir de l'hypothèse qu'un char fasse 8 bits... cela peut etre facilement testé avec le code suivant, qui peut très bien servir à déterminer le multiplicateur fournis à sizeof()

Code :

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

1
2
3
4
5
6
7
8
 
int taillechar=0;
do
{
    taillechar++;
    a=1<<taillechar;
}while(a!=0);
printf("%d\n",taillechar);

Ou alors on peut écrire:

Code :

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

1
2
3
#include <limits.h>
/* ... */
int taille = sizeof(int) * CHAR_BIT;

C'est standard! En ce qui concerne les problèmes de "boutisme", l'utilisation des opérateurs binaires &, >> et << est sûre de ce point de vue.

A part cela, j'ai cherché à réaliser une implantation portable pour l'affichage de la représentation binaire d'un double ou d'un float, et là je ne vois pas. Les opérateurs binaires ne sont en effet pas définis pour les nombre flottants. Si vous avez des propositions...

Thierry

[Jean-Marc.Bourguet]

... mais uniquement des entiers convertis en non signés, pas des flottants. Il me semble (mais j'ai peut être rêvé) que C99 a un format de printf() pour montrer un flottant en hexadécimal...

Tu n'as pas rêvé: %a et %A.

[Jean-Marc.Bourguet]

Les opérateurs binaires ne sont en effet pas définis pour les nombre flottants. Si vous avez des propositions...

frexp puis des multiplications par 2.

[David.Schris]

[...]

Code :

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

1
2
3
4
5
6
7
8
int val=200;
/* il nous faut 8 caractère pour chaque octets
   comme cette taille sera souvent utilisée, autant s'en souvenir */
int i;
int taille=sizeof(int)*8;
/* à l'allocation, il faut prévoir la place pour le '\0' */
char *result=malloc(taille+1);
/* ... */

NOTA:

• Tu remarqueras que j'utilises de préférence un tableau de caractères alloué dynamiquement...
  
  C'est pour l'unique raison qu'il est dangeureux de faire la moindre hypothèse concernant la taille utilisée par un entier dans la mémoire.[...]

Certes, les hypothèses peuvent être dangereuses. Mais cela justifie-t-il une allocation dynamique ?
Aurais-tu peur que la taille des entiers change entre la compilation et l'exécution de ton programme ?

Code :

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

1
2
3
4
5
6
7
#include <limits.h>
/* ... */
#define INT_BIT (sizeof(int)*CHAR_BIT)
/* ... */
int taille = INT_BIT;
char result[INT_BIT+1]; /* +1 pour le '\0' final */
/* ...*/

[sandball22]

Je voudrais faire la meme chose mais avec desflottants. Par example 20.5 a representer sous forme bianire