Преобразование значений с плавающей запятой из прямого порядка байтов в прямой

просто поменять местами четыре байта работает

float ReverseFloat( const float inFloat )
{
   float retVal;
   char *floatToConvert = ( char* ) & inFloat;
   char *returnFloat = ( char* ) & retVal;

   // swap the bytes into a temporary buffer
   returnFloat[0] = floatToConvert[3];
   returnFloat[1] = floatToConvert[2];
   returnFloat[2] = floatToConvert[1];
   returnFloat[3] = floatToConvert[0];

   return retVal;
}

Вот функция, которая может изменить порядок байтов любого типа.

template <typename T>
T bswap(T val) {
    T retVal;
    char *pVal = (char*) &val;
    char *pRetVal = (char*)&retVal;
    int size = sizeof(T);
    for(int i=0; i<size; i++) {
        pRetVal[size-1-i] = pVal[i];
    }

    return retVal;
}

Я нашел что-то примерно такое давным-давно. Это было хорошо для смеха, но глотать на свой страх и риск. Я его даже не компилировал:

void * endian_swap(void * arg)
{
    unsigned int n = *((int*)arg);
    n = ((n >>  8) & 0x00ff00ff) | ((n <<  8) & 0xff00ff00);
    n = ((n >> 16) & 0x0000ffff) | ((n << 16) & 0xffff0000);
    *arg = n;   

    return arg;
}

Элегантным способом обмена байтами является использование объединения:

float big2little (float f)
{
    union
    {
        float f;
        char b[4];
    } src, dst;

    src.f = f;
    dst.b[3] = src.b[0];
    dst.b[2] = src.b[1];
    dst.b[1] = src.b[2];
    dst.b[0] = src.b[3];
    return dst.f;
}

Следуя рекомендации jjmerelo написать цикл, более общим решением может быть:

typedef float number_t;
#define NUMBER_SIZE sizeof(number_t)

number_t big2little (number_t n)
{
    union
    {
        number_t n;
        char b[NUMBER_SIZE];
    } src, dst;

    src.n = n;
    for (size_t i=0; i<NUMBER_SIZE; i++)
        dst.b[i] = src.b[NUMBER_SIZE-1 - i];

    return dst.n;
}

Не копируйте данные напрямую в тип с плавающей запятой. Сохраните его как данные char, поменяйте местами байты и затем обработайте его как число с плавающей запятой.

Возможно, было бы проще использовать ntoa и связанные с ним функции для преобразования из сети в хост и из хоста в сеть. Преимущество в том, что это будет переносимым. Вот ссылка на статью, объясняющую как это сделать.

Из SDL_endian.h с небольшими изменениями:

std::uint32_t Swap32(std::uint32_t x)
{
    return static_cast<std::uint32_t>((x << 24) | ((x << 8) & 0x00FF0000) |
                                      ((x >> 8) & 0x0000FF00) | (x >> 24));
}

float SwapFloat(float x)
{
    union
    {
        float f;
        std::uint32_t ui32;
    } swapper;
    swapper.f = x;
    swapper.ui32 = Swap32(swapper.ui32);
    return swapper.f;
}

Это значение является числом с плавающей запятой, но когда я "memcpy" значение преобразую в тип числа с плавающей запятой win32, а затем вызываю _byteswap_ulong для этого значения, я всегда получаю 0,0000?

Это должно работать. Можете ли вы опубликовать код, который у вас есть?

Однако, если вы заботитесь о производительности (возможно, нет, в этом случае вы можете игнорировать остальное), должна быть возможность избежать memcpy, либо напрямую загрузив его в целевое местоположение и подкачивая там байты, либо используя своп который выполняет подкачку при копировании.

в некоторых случаях, особенно в Modbus: сетевой порядок байтов для числа с плавающей запятой:

nfloat[0] = float[1]
nfloat[1] = float[0]
nfloat[2] = float[3]
nfloat[3] = float[2]