double hex string & hex corde à double

Ce que je suis en train de faire est de convertir un double en chaîne hexadécimale et puis de nouveau à double.

Le code suivant effectue la conversion double-chaîne hexadécimale.

char * double2HexString(double a)
{
   char *buf = new char[17]; //double is 8-byte long, so we have 2*8 + terminating char * double2HexString(double a)
{
char *buf = new char[17]; //double is 8-byte long, so we have 2*8 + terminating \0
char *d2c;
d2c = (char *) &a;
char *n = buf;
int i;
for(i = 0; i < 8; i++)
{
sprintf(n, "%02X", *d2c++);
n += 2;
} 
*(n) = '\0';
}
   char *d2c;
   d2c = (char *) &a;
   char *n = buf;
   int i;
   for(i = 0; i < 8; i++)
   {
      sprintf(n, "%02X", *d2c++);
      n += 2;
   } 
   *(n) = 'char * double2HexString(double a)
{
char *buf = new char[17]; //double is 8-byte long, so we have 2*8 + terminating \0
char *d2c;
d2c = (char *) &a;
char *n = buf;
int i;
for(i = 0; i < 8; i++)
{
sprintf(n, "%02X", *d2c++);
n += 2;
} 
*(n) = '\0';
}
';
}

Cela semble fonctionner, cependant, je ne suis pas sûr de la façon de convertir la chaîne résultante arrière à double.
Veuillez informer 🙂

Êtes-vous en train d'imprimer les octets brutes, ou l'hexadécimal de la représentation du nombre? Aussi, à faire vous vous souciez de la portabilité de la chaîne elle-même (pas le code)?
Préférez-vous une solution qui est portable, facile à code/lire, ou rapide?
Je préfère la solution qui est facile à coder et à lire. J'ai besoin de cela pour passer des arguments entre les programmes. Être plus précis, premier programme engendre l'autre et passe à 2 doubles codé en hexadécimal de la chaîne. Strager, qu'entendez-vous par "la portabilité de la chaîne elle-même"?
La portabilité peut être un problème si vous utilisez cette sur deux HW plattforms parce que vous utilisez la forme binaire de données. Big Endian/Little Endian machine, ordre des octets de Réseau et ces choses doivent être prises en compte.

InformationsquelleAutor | 2009-01-30

c c++double hex

Je suis surpris de voir que personne n'a trouver la solution standard, qui est la %a spécificateur de format ISO Standard C99.

#include <iostream>
#include <string>
#include <stdio.h>

std::string double2hexastr(double d) {

  char buffer[25] = { 0 };

  ::snprintf(buffer, 25, "%A", d); //TODO Check for errors

  return buffer;
}

double hexastr2double(const std::string& s) {

  double d = 0.0;

  ::sscanf(s.c_str(), "%lA", &d); //TODO Check for errors

  return d;
}


int main() {

  std::cout << "0.1 in hexadecimal: " << double2hexastr(0.1) << std::endl;

  std::cout << "Reading back 0X1.999999999999AP-4, it is ";

  std::cout << hexastr2double("0X1.999999999999AP-4") << std::endl;

}

Je ne fonctionne pas fo long double.
La question posée pour double et pas pour long double. Si vous désirez le faire pour long double, vous avez besoin de la "%LA" indicateur de conversion. Vous pouvez upvote ma réponse maintenant.

InformationsquelleAutor Ali

char *doubleToRawString(double x) {
    //Assumes sizeof(long long) == 8.

    char *buffer = new char[32];
    sprintf(buffer, "%llx", *(unsigned long long *)&x);  //Evil!
    return buffer;
}

double rawStringToDouble(const char *s) {
    //Assumes sizeof(long long) == 8.

    double ret;
    sscanf(s, "%llx", (unsigned long long *)&ret);  //Evil!
    return ret;
}

InformationsquelleAutor strager

char *doubleToRawString(double x) {
    const size_t bytesInDouble = 8;

    union {
        double value;
        unsigned char bytes[bytesInDouble];
    } u;

    u.value = x;

    char *buffer = new char[bytesInDouble * 2 + 1];
    unsigned char *input = u.bytes;
    char *output = buffer;

    for(int i = 0; i < bytesInDouble; ++i) {
        sprintf(output, "%02hhX", *input);

        ++input;
        output += 2;
    }

    return buffer;
}

double rawStringToDouble(const char *input) {
    const size_t bytesInDouble = 8;

    union {
        double value;
        unsigned char bytes[bytesInDouble];
    } u;

    unsigned char *output = u.bytes;

    for(int i = 0; i < bytesInDouble; ++i) {
        sscanf(input, "%02hhX", output);

        input += 2;
        ++output;
    }

    return u.value;
}

Cette utilise le non-standard hh modificateur. Si vous ne voulez pas l'utiliser, utilisation:

unsigned int tmp = *input;
sprintf(output, "%02X", tmp);

unsigned int tmp;
sscanf(input, "%02X", &tmp);
*output = tmp;

InformationsquelleAutor strager

Pour MFC, convertir double de CString 🙂

CString MFCClass::DoubleToCString(double d, int beforKomma)
{
    char a[17]="0123456789ABCDEF";
    CString str = _T("");
    double dInt=0,dPunkt=0;
    bool is_otr=0;
    if (d<0) {is_otr=1; d=-d;}
    dPunkt = modf(d, &dInt);
    //целая часть
    long ld = (long)dInt;
    long mask = 0xf;
    int it;
    while(ld>0)
    {
        it = ld&mask;
        ld = ld>>4;
        str.Insert(0,a[it]);
    };
    //дробная часть
    //если целая часть 0:
    if (str.GetLength()==0) str += _T("0");
    str += _T(".");
    for (int i=0; i<beforKomma; i++)
    {
        dPunkt*=16;
        dPunkt = modf(dPunkt, &dInt);
        str += a[(int)dInt];
    }

    if (is_otr) str.Insert(0,_T("-"));
    return (str);
}

-345.86783907228863 -> "-159.DE2" (beforKomma=3)

InformationsquelleAutor RusVIPer

En utilisant sprintf est lent, pour être honnête, mais vous pouvez revenir avec sscanf, faisant presque exactement la même chose.

Eh bien, en fait, vous devez copier tous les deux des caractères dans un tampon de chaîne, à décoder chacun individuellement. Mon premier essai, ci-dessous est incorrect:

double hexString2Double(char *buf)
{
  char *buf2 = new char[3];
  double a;
  char* c2d;
  c2d = (char *) &a;
  int i;

  buf2[2] = 'double hexString2Double(char *buf)
{
char *buf2 = new char[3];
double a;
char* c2d;
c2d = (char *) &a;
int i;
buf2[2] = '\0'
for(i = 0; i < 16; i++)
{
buf2[0] = *buf++;
buf2[1] = *buf++;
sscanf(buf2, "%X", c2d++);
}
return a;
}
'

  for(i = 0; i < 16; i++)
  {
    buf2[0] = *buf++;
    buf2[1] = *buf++;
    sscanf(buf2, "%X", c2d++);
  }

  return a;
}

Vous voyez, %X est décodé comme un int, pas comme un octet. Il pourrait même travail, en fonction sur le bas de la fin/haute-endian questions, mais en gros, c'est cassé. Alors, nous allons essayer de contourner:

double hexString2Double(char *buf)
{
  char *buf2 = new char[3];
  double a;
  char* c2d;
  c2d = (char *) &a;
  int i;
  int decoder;

  buf2[2] = 'double hexString2Double(char *buf)
{
char *buf2 = new char[3];
double a;
char* c2d;
c2d = (char *) &a;
int i;
int decoder;
buf2[2] = '\0'
for(i = 0; i < 16; i++)
{
buf2[0] = *buf++;
buf2[1] = *buf++;
sscanf(buf2, "%X", &decoder);
c2d++ = (char) decoder;
}
return a;
}
'

  for(i = 0; i < 16; i++)
  {
    buf2[0] = *buf++;
    buf2[1] = *buf++;
    sscanf(buf2, "%X", &decoder);
    c2d++ = (char) decoder;
  }

  return a;
}

De limitation des erreurs de syntaxe et d', je pense que cela devrait fonctionner.

InformationsquelleAutor Daniel C. Sobral

Presque la même procédure doit faire

void hex2double(const char* buf, double& a)
{
   char tmpbuf[3]={0};
   char *d2c;
   unsigned int tmp;
   d2c = (char *) &a;
   char *n = buf;
   int i;
   for(i = 0; i < 8; i++)
   {
      tmpbuf[0]=*buf++;
      tmpbuf[1]=*buf++;
      sscanf(tmpbuf, "%X", &tmp);
      *d2c++=tmp;
   }
}

Rapide & sale.

Noter, cependant, que c'est jouer avec le feu. Tout d'abord, votre hex chaînes sont utilisables uniquement sur les machines avec le double même format et la même boutisme. Deuxièmement, les fonctions de conversion sont courts sur le strict aliasing règle.

InformationsquelleAutor jpalecek

#include <stdio.h>
main() {
  union double_ull_t {
    double d;
    unsigned long long u;
  } x;
  scanf("%lf",&x.d);
  printf("%016llX %lf\n",x.u,x.d);
  scanf("%016llX",&x.u);
  printf("%016llX %lf\n",x.u,x.d);
}

Peut-être pas la solution la plus efficace, mais le plus facile à coder.

ressemble strager me battre pour cette approche, et avec de plus en plus applicable de la mise en œuvre

InformationsquelleAutor Sparr

0

Vous souhaitez utiliser une union et d'éviter cette mauvaise habitude:

char *d2c;

d2c = (char *) &a;

Pour juste l'impression ce n'est pas mauvais, son lorsque vous essayez de modifier d2c et ensuite utiliser un est quand vous avez des ennuis. (même chose est vraie pour tous les deux variables ou des pointeurs (ou tableaux) partage le même (théorique) de la mémoire.
```
union
{
    double f;
    unsigned long ul;
} myun;

myun.f = a;
printf("0x%lX",myun.ul);

to go the other way (scanf is also a very dangerous function that should be avoided).

myun.ul=strtoul(string,NULL,16);
a=myun.f;
```
InformationsquelleAutor old_timer

Je suis ci-dessous à l'aide de la fonction de convertir un double en hexadécimal.

char * double2HexString(double a) 
{ 
   char *buf = new char[17]; //double is 8-byte long, so we have 2*8 + terminating char * double2HexString(double a) 
{ 
char *buf = new char[17]; //double is 8-byte long, so we have 2*8 + terminating \0 
char *d2c; 
d2c = (char *) &a; 
char *n = buf; 
int i; 
for(i = 0; i < 8; i++) 
{ 
sprintf(n, "%02X", *d2c++); 
n += 2; 
}  
*(n) = '\0'; 
}  
 
   char *d2c; 
   d2c = (char *) &a; 
   char *n = buf; 
   int i; 
   for(i = 0; i < 8; i++) 
   { 
      sprintf(n, "%02X", *d2c++); 
      n += 2; 
   }  
   *(n) = 'char * double2HexString(double a) 
{ 
char *buf = new char[17]; //double is 8-byte long, so we have 2*8 + terminating \0 
char *d2c; 
d2c = (char *) &a; 
char *n = buf; 
int i; 
for(i = 0; i < 8; i++) 
{ 
sprintf(n, "%02X", *d2c++); 
n += 2; 
}  
*(n) = '\0'; 
}  
'; 
}

passant 1.0 & 16.0 à cette fonction, le retour aux valeurs observées sont 000000000000FF37 & 0000000000003040 respectivement. Je pense que nous devrions obtenir 1 & 10.

InformationsquelleAutor Sai Krishna V

Vous devez vous connecter pour publier un commentaire.