удвойтесь для преобразовывания в шестнадцатеричную систему строки и шестнадцатеричной строки для удвоения

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;
}

Это использует нестандартное hh модификатор. Если Вы не хотите использовать это, используйте:

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

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

Используя sprintf является медленным, честно говоря, но можно вернуться он с sscanf, делая почти точно то же самое.

Ну, на самом деле необходимо было бы скопировать каждого два символа в буферную строку, для декодирования каждого индивидуально. Моя первая попытка, ниже является неправильной:

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;
}

Вы видите, %X декодируется как интервал, не как байт. Это могло бы даже работать, в зависимости от проблем low-ending/high-endian, но это в основном повреждается. Так, давайте попытаемся обойти это:

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;
}

Запрещая синтаксические ошибки и такой, я думаю, что это должно работать.

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;
}

Почти та же процедура должна сделать

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;
   }
}

Быстрый и грязный.

Обратите внимание, однако, что это играет с огнем. Во-первых, Ваши шестнадцатеричные строки только применимы на машинах с тем же двойным форматом и тем же порядком байтов. Во-вторых, функции преобразования коротки на строгом правиле искажения.

#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);
}

Возможно, не наиболее эффективное решение, но самое легкое для кодирования.

Вы хотите использовать объединение и избежать этой дурной привычки:

char * d2c;

d2c = (char *) & a;

Для простой печати это неплохо, когда вы пытаетесь изменить d2c, а затем используете a, у вас возникают проблемы. (то же самое верно для любых двух переменных или указателей (или массивов), использующих одну и ту же (теоретическую) память.

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;

Вы хотите быть уверены, что используете кэш PHP, такой как XCache или APC. Ваши PHP-файлы должны быть в памяти, и вы не должны беспокоиться о ваших включениях попадание на диск вообще.

Мне определенно было бы легче, если бы вы распались, как мыслящие функции/классы, на свои собственные файлы.

Для небольших файлов, вероятно, гораздо быстрее просто сохранить содержимое файла в памяти

file = open('C:\\some_text.txt')
fileContents = file.readlines()
print fileContents
print fileContents # This line will work as well.

Конечно, если это большой файл, это может привести к нагрузке на ОЗУ.

Я использую приведенную ниже функцию, чтобы преобразовать двойную в шестнадцатеричную.

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'; 
}  

передавая 1,0 и 16,0 этой функции, наблюдаемые возвращаемые значения равны 000000000000FF37 и 0000000000003040 соответственно. Я думаю, мы должны получить 1 & 10.