如何在C++中的big-endian和little-endian值之间进行转换？

简单的说:

#include 

template 
T swap_endian(T u)
{
    static_assert (CHAR_BIT == 8, "CHAR_BIT != 8");

    union
    {
        T u;
        unsigned char u8[sizeof(T)];
    } source, dest;

    source.u = u;

    for (size_t k = 0; k < sizeof(T); k++)
        dest.u8[k] = source.u8[sizeof(T) - k - 1];

    return dest.u;
}

用法:swap_endian(42).

来自Rob Pyke 的Byte Order Fallacy:

假设您的数据流具有小端编码的32位整数.以下是如何提取它(假设无符号字节):

i = (data[0]<<0) | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);

如果它是big-endian,这里是如何提取它:

i = (data[3]<<0) | (data[2]<<8) | (data[1]<<16) | (data[0]<<24);

TL; DR:不要担心你的平台本机顺序,所有重要的是你正在阅读的流的字节顺序,你最好希望它的定义很好.

注意:在评论中注释到没有显式类型转换,重要的是data成为unsigned char或者数组uint8_t.使用signed char或char(如果有符号)将导致data[x]被提升为整数并data[x] << 24可能将1移入符号位UB.

如果您出于网络/主机兼容性的目的这样做,您应该使用:

ntohl() //Network to Host byte order (Long)
htonl() //Host to Network byte order (Long)

ntohs() //Network to Host byte order (Short)
htons() //Host to Network byte order (Short)

如果您出于某种其他原因而执行此操作,则此处提供的byte_swap解决方案之一可以正常工作.

我从这篇文章中提出了一些建议并将它们组合在一起形成:

#include 
#include 
#include 
#include 

enum endianness
{
    little_endian,
    big_endian,
    network_endian = big_endian,

    #if defined(BOOST_LITTLE_ENDIAN)
        host_endian = little_endian
    #elif defined(BOOST_BIG_ENDIAN)
        host_endian = big_endian
    #else
        #error "unable to determine system endianness"
    #endif
};

namespace detail {

template
struct swap_bytes
{
    inline T operator()(T val)
    {
        throw std::out_of_range("data size");
    }
};

template
struct swap_bytes
{
    inline T operator()(T val)
    {
        return val;
    }
};

template
struct swap_bytes
{
    inline T operator()(T val)
    {
        return ((((val) >> 8) & 0xff) | (((val) & 0xff) << 8));
    }
};

template
struct swap_bytes
{
    inline T operator()(T val)
    {
        return ((((val) & 0xff000000) >> 24) |
                (((val) & 0x00ff0000) >>  8) |
                (((val) & 0x0000ff00) <<  8) |
                (((val) & 0x000000ff) << 24));
    }
};

template<>
struct swap_bytes
{
    inline float operator()(float val)
    {
        uint32_t mem =swap_bytes()(*(uint32_t*)&val);
        return *(float*)&mem;
    }
};

template
struct swap_bytes
{
    inline T operator()(T val)
    {
        return ((((val) & 0xff00000000000000ull) >> 56) |
                (((val) & 0x00ff000000000000ull) >> 40) |
                (((val) & 0x0000ff0000000000ull) >> 24) |
                (((val) & 0x000000ff00000000ull) >> 8 ) |
                (((val) & 0x00000000ff000000ull) << 8 ) |
                (((val) & 0x0000000000ff0000ull) << 24) |
                (((val) & 0x000000000000ff00ull) << 40) |
                (((val) & 0x00000000000000ffull) << 56));
    }
};

template<>
struct swap_bytes
{
    inline double operator()(double val)
    {
        uint64_t mem =swap_bytes()(*(uint64_t*)&val);
        return *(double*)&mem;
    }
};

template
struct do_byte_swap
{
    inline T operator()(T value)
    {
        return swap_bytes()(value);
    }
};
// specialisations when attempting to swap to the same endianess
template struct do_byte_swap { inline T operator()(T value) { return value; } };
template struct do_byte_swap { inline T operator()(T value) { return value; } };

} // namespace detail

template
inline T byte_swap(T value)
{
    // ensure the data is only 1, 2, 4 or 8 bytes
    BOOST_STATIC_ASSERT(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8);
    // ensure we're only swapping arithmetic types
    BOOST_STATIC_ASSERT(boost::is_arithmetic::value);

    return detail::do_byte_swap()(value);
}

从big-endian到little-endian的过程与从little-endian到big-endian的过程相同.

这是一些示例代码:

void swapByteOrder(unsigned short& us)
{
    us = (us >> 8) |
         (us << 8);
}

void swapByteOrder(unsigned int& ui)
{
    ui = (ui >> 24) |
         ((ui<<8) & 0x00FF0000) |
         ((ui>>8) & 0x0000FF00) |
         (ui << 24);
}

void swapByteOrder(unsigned long long& ull)
{
    ull = (ull >> 56) |
          ((ull<<40) & 0x00FF000000000000) |
          ((ull<<24) & 0x0000FF0000000000) |
          ((ull<<8) & 0x000000FF00000000) |
          ((ull>>8) & 0x00000000FF000000) |
          ((ull>>24) & 0x0000000000FF0000) |
          ((ull>>40) & 0x000000000000FF00) |
          (ull << 56);
}

有一个名为BSWAP的汇编指令,可以非常快速地为您进行交换.你可以在这里阅读它.

Visual Studio,或更确切地说是Visual C++运行时库,具有此平台内在函数,称为_byteswap_ushort(), _byteswap_ulong(), and _byteswap_int64().其他平台应该存在类似的情况,但我不知道它们会被称为什么.

我们用模板完成了这个.你可以这样:

// Specialization for 2-byte types.
template<>
inline void endian_byte_swapper< 2 >(char* dest, char const* src)
{
    // Use bit manipulations instead of accessing individual bytes from memory, much faster.
    ushort* p_dest = reinterpret_cast< ushort* >(dest);
    ushort const* const p_src = reinterpret_cast< ushort const* >(src);
    *p_dest = (*p_src >> 8) | (*p_src << 8);
}

// Specialization for 4-byte types.
template<>
inline void endian_byte_swapper< 4 >(char* dest, char const* src)
{
    // Use bit manipulations instead of accessing individual bytes from memory, much faster.
    uint* p_dest = reinterpret_cast< uint* >(dest);
    uint const* const p_src = reinterpret_cast< uint const* >(src);
    *p_dest = (*p_src >> 24) | ((*p_src & 0x00ff0000) >> 8) | ((*p_src & 0x0000ff00) << 8) | (*p_src << 24);
}

如果您这样做是为了在不同平台之间传输数据,请查看ntoh和hton函数.

和你在C中做的一样:

short big = 0xdead;
short little = (((big & 0xff)<<8) | ((big & 0xff00)>>8));

您还可以声明一个无符号字符向量,将输入值memcpy到其中,将字节转换为另一个向量并将字节记忆输出,但这将比bit-twiddling长几个数量级,特别是对于64位值.

在大多数POSIX系统上(通过它不在POSIX标准中)有endian.h,它可用于确定系统使用的编码.从那里它是这样的:

unsigned int change_endian(unsigned int x)
{
    unsigned char *ptr = (unsigned char *)&x;
    return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
}

这交换顺序(从big-endian到little endian):

如果您的数字为0xDEADBEEF(在小端系统上存储为0xEFBEADDE),则ptr [0]将为0xEF,ptr [1]为0xBE等.

但是如果你想将它用于网络,那么htons,htonl和htonll(以及它们的反向ntohs,ntohl和ntohll)将有助于从主机顺序转换为网络顺序.

#define htonl(x) _byteswap_ulong(x)