Logo GNT
Actualités Tests & Guides Bons Plans
Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11
Entraide Développement Développement Langage C affichage des bits d'une variable double

affichage des bits d'une variable double

9 réponses
Avatar
frederic.sicot
Bonjour,

je souhaiterai afficher les bits d'une varaible de type double. j'ai
regardé ce forum et vu les exemples traitant les variables entières
avec des opérateurs de décalage et de masquage. J'ai essayé de
reproduire ce type de fonctions car après tout, il suffit juste de
connaître le nombre de bits qui composent ma variable. Mais d'après le
Kernighan & Ritchie, les opérateur logiques de bits ne peuvent pas
être employés avec des double (cf. $ 2.9).

Donc je ne sais pas comment faire, si quelqu'un a une solution, je
suis preneur.

Merci
Frédéric Sicot
Signaler un problème avec ce contenu

9 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Avatar
Raphael TOSTO
"Frederic Sicot" a écrit dans le
message de news:
Bonjour,

je souhaiterai afficher les bits d'une varaible de type double. j'ai
regardé ce forum et vu les exemples traitant les variables entières
avec des opérateurs de décalage et de masquage. J'ai essayé de
reproduire ce type de fonctions car après tout, il suffit juste de
connaître le nombre de bits qui composent ma variable. Mais d'après le
Kernighan & Ritchie, les opérateur logiques de bits ne peuvent pas
être employés avec des double (cf. $ 2.9).



void AfficherBit ( double Dbl )
{
char *Ptr ;
int i ;

for ( i=0, Ptr=(char*)&Dbl ; i<sizeof(double) ; Ptr ++, i++)
printf ( "%08X", (* Ptr) ) ;
}

Avatar
Yves ROMAN

"Frederic Sicot" a écrit dans le
message de news:
Bonjour,

je souhaiterai afficher les bits d'une varaible de type double. j'ai
regardé ce forum et vu les exemples traitant les variables entières
avec des opérateurs de décalage et de masquage. J'ai essayé de
reproduire ce type de fonctions car après tout, il suffit juste de
connaître le nombre de bits qui composent ma variable. Mais d'après le
Kernighan & Ritchie, les opérateur logiques de bits ne peuvent pas
être employés avec des double (cf. $ 2.9).



void AfficherBit ( double Dbl )
{
char *Ptr ;
int i ;

for ( i=0, Ptr=(char*)&Dbl ; i<sizeof(double) ; Ptr ++, i++)
printf ( "%08X", (* Ptr) ) ;


Pour eviter les extensions de signes intempestives
printf("%02X", (unsigned char)(* Ptr) ) ;

}


Ca donne une methode pour convertir un double en tableau de char (
char[sizeof(double)] )
Apres tu peux appliquer la méthode pour afficher les bits de chaque char


Avatar
Raphael TOSTO
"Yves ROMAN" a écrit dans le message de
news:

"Frederic Sicot" a écrit dans le
message de news:
Bonjour,

je souhaiterai afficher les bits d'une varaible de type double. j'ai
regardé ce forum et vu les exemples traitant les variables entières
avec des opérateurs de décalage et de masquage. J'ai essayé de
reproduire ce type de fonctions car après tout, il suffit juste de
connaître le nombre de bits qui composent ma variable. Mais d'après le
Kernighan & Ritchie, les opérateur logiques de bits ne peuvent pas
être employés avec des double (cf. $ 2.9).



void AfficherBit ( double Dbl )
{
char *Ptr ;
int i ;

for ( i=0, Ptr=(char*)&Dbl ; i<sizeof(double) ; Ptr ++, i++)
printf ( "%08X", (* Ptr) ) ;


Pour eviter les extensions de signes intempestives
printf("%02X", (unsigned char)(* Ptr) ) ;



Pour le unsigned char OK, bien que je ne vois pas ce qui me gènerais dans
l'extension de signe, les perfs ?.
Mais le '%02X' m'échappe quelque peu.


Ca donne une methode pour convertir un double en tableau de char (
char[sizeof(double)] )


Et donc suivant ton argument il faut comprendre unsigned char a la place de
char ?

Apres tu peux appliquer la méthode pour afficher les bits de chaque char




Avatar
Yves ROMAN

"Yves ROMAN" a écrit dans le message de
news:

"Frederic Sicot" a écrit dans le
message de news:
Bonjour,

je souhaiterai afficher les bits d'une varaible de type double. j'ai
regardé ce forum et vu les exemples traitant les variables entières
avec des opérateurs de décalage et de masquage. J'ai essayé de
reproduire ce type de fonctions car après tout, il suffit juste de
connaître le nombre de bits qui composent ma variable. Mais d'après le
Kernighan & Ritchie, les opérateur logiques de bits ne peuvent pas
être employés avec des double (cf. $ 2.9).



void AfficherBit ( double Dbl )
{
char *Ptr ;
int i ;

for ( i=0, Ptr=(char*)&Dbl ; i<sizeof(double) ; Ptr ++, i++)
printf ( "%08X", (* Ptr) ) ;


Pour eviter les extensions de signes intempestives
printf("%02X", (unsigned char)(* Ptr) ) ;



Pour le unsigned char OK, bien que je ne vois pas ce qui me gènerais dans
l'extension de signe, les perfs ?.


Si Ptr pointe vers un 'signed char' qui a une valeur negativeca produit des
problèmes
char toto = 70 ;
toto *= 2 ;
printf("%02X %02X %dn",toto,(unsigned char)toto,toto) ;
donne
FFFFFF8C 8C -116

Mais le '%02X' m'échappe quelque peu.



%X va afficher de l'hexa. Comme tu affiches 'octet' par 'octet', ce ne fait que
2 chiffres hexa.
Pour afficher les 8 bits, il faut faire une boucle avec décalage et masques pour
extraire chaque bit un par un et afficher chacun séparément


Ca donne une methode pour convertir un double en tableau de char (
char[sizeof(double)] )


Et donc suivant ton argument il faut comprendre unsigned char a la place de
char ?


Oui


Apres tu peux appliquer la méthode pour afficher les bits de chaque char






Avatar
Raphael TOSTO
"Yves ROMAN" a écrit dans le message de
news:
{
char *Ptr ;
int i ;

for ( i=0, Ptr=(char*)&Dbl ; i<sizeof(double) ; Ptr ++, i++)
printf ( "%08X", (* Ptr) ) ;


Pour eviter les extensions de signes intempestives
printf("%02X", (unsigned char)(* Ptr) ) ;



Pour le unsigned char OK, bien que je ne vois pas ce qui me gènerais
dans


l'extension de signe, les perfs ?.


Si Ptr pointe vers un 'signed char' qui a une valeur negativeca produit
des

problèmes
char toto = 70 ;
toto *= 2 ;
printf("%02X %02X %dn",toto,(unsigned char)toto,toto) ;
donne
FFFFFF8C 8C -116

Mais le '%02X' m'échappe quelque peu.





Quel piège à c.., et je suis tombé en plein dedans.
Merci, d'avoir rattrapé tous les âneries que j'ai sorti.




Avatar
Raphael TOSTO
"Raphael TOSTO" a écrit dans le message de
news:bu3fjf$hal$

Et en plus cela ne repondait même pas à l'attente Frederic Sicot:

Deuxième chance :


void AfficherBitChar ( unsigned char Car )
{
int i ;

printf ( "n%02X ", Car ) ;

for ( i=0 ; i<8 ; i++, Car <<= 1 )
printf ( "%d", (Car & 0x80 ? 1 : 0) ) ;
}


void AfficherBitDouble ( double Dbl )
{
unsigned char *Ptr ;
int i ;

for ( i=0, Ptr=(unsigned char*)&Dbl ; i<sizeof(double) ; Ptr ++, i++)
AfficherBitChar (* Ptr) ;
}


Précision implicitement j'ai pris 1 char = 8 bits. Sinon utiliser
(CHAR_BIT)
Avatar
Vincent Lefevre
Dans l'article ,
Frederic Sicot écrit:

je souhaiterai afficher les bits d'une varaible de type double.


Pour quoi faire? Je pose la question, car il y a divers problèmes qu'il
faut peut-être prendre en compte. Par exemple, la représentation d'un
double en mémoire, même au format IEEE754, dépend de l'implémentation;
et avec gcc (à moins d'utiliser -ffloat-store), une variable peut
contenir une valeur en précision étendue, ce qui est un bug.

--
Vincent Lefèvre - Web: <http://www.vinc17.org/> - 100%
validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International
des Jeux Mathématiques et Logiques, TETRHEX, etc.
Work: CR INRIA - computer arithmetic / SPACES project at LORIA

Avatar
Pierre Maurette
"Frederic Sicot" a écrit dans le
message de news:
Bonjour,

je souhaiterai afficher les bits d'une varaible de type double. j'ai
regardé ce forum et vu les exemples traitant les variables entières
avec des opérateurs de décalage et de masquage. J'ai essayé de
reproduire ce type de fonctions car après tout, il suffit juste de
connaître le nombre de bits qui composent ma variable. Mais d'après le
Kernighan & Ritchie, les opérateur logiques de bits ne peuvent pas
être employés avec des double (cf. $ 2.9).

Donc je ne sais pas comment faire, si quelqu'un a une solution, je
suis preneur.


Une horreur de 1996 ( à refaire, mais ça fonctionne sous Microsoft, Borland
et le Genou):
Pour appeler :

char bouffeur[256];
double f=3.14159;
bool blocs=true;

printf("Nombre de caracteres: %dn", MemToBin((byte*)&f, sizeof(f),
bouffeur, blocs, SENS_CROISSANT));
printf("%sn", bouffeur);

printf("Nombre de caracteres: %dn", MemToHex((byte*)&f, sizeof(f),
bouffeur, blocs, SENS_CROISSANT));
printf("%sn", bouffeur);

Les fonctions :

#include <stdlib.h>

//Pour le sens
#define SENS_CROISSANT true
#define SENS_DECROISSANT false

// mes habitudes C++
#define true 1
#define false 0
#define bool int

typedef unsigned char byte;


int MemToBin(byte*ptr, int nb_octets, char*bin, bool blocs, bool croissant)
{
int compt_bit, compt_oct, j=0;
byte*oct_ptr;

if(croissant) oct_ptr=ptr;
else
oct_ptr=ptr+nb_octets-1;

for(compt_oct=0; compt_oct<nb_octets; compt_oct++)
{
for(compt_bit=0; compt_bit<=7; compt_bit++)
{
/* bin[j++]='0' +(((*oct_ptr)=_crotl(*oct_ptr, 1))&1); */
bin[j++]='0' +(((*oct_ptr=(*oct_ptr*2)|(*oct_ptr/128)))&1);
if((compt_bit==3)&&blocs) bin[j++]='.';
}
if(croissant) oct_ptr++;
else
oct_ptr--;
if(blocs&&(compt_oct!=nb_octets-1)) { bin[j++]='-'; bin[j++]='-'; }
}
bin[j++]='';
return (j);
}


int MemToHex(byte*ptr, int nb_octets, char*hex, bool blocs, bool croissant)
{
int compt_oct, j=0;
byte*oct_ptr;
byte uc;

if(croissant) oct_ptr=ptr;
else
oct_ptr=ptr+nb_octets-1;

for(compt_oct=0; compt_oct<nb_octets; compt_oct++)
{
uc=((*oct_ptr)&0xF0)/16;
hex[j++]='0' +uc+(7*(uc>9));
uc=(*oct_ptr)&0xF;
hex[j++]='0' +uc+(7*(uc>9));

if(croissant) oct_ptr++;
else
oct_ptr--;
if(blocs&&(compt_oct!=nb_octets-1)) { hex[j++]='-'; }
}
hex[j++]='';
return (j);
}

Sinon, j'ai la version C++ (pas mieux) qui permet de paramétrer les
séparateurs et possède des valeurs par défaut.
Le reste est en Delphi.

Pas de SAV ;-)

Pierre (honteux)

Avatar
frederic.sicot
merci à tous !

Frédéric Sicot