可移植性

Question

htonl()的手册页似乎暗示您只能将其用于最多32位值。（实际上，ntohl()是为无符号长度定义的，在我的平台上是32位。我想如果无符号长整数是8个字节，它将适用于64位整数。）

我的问题是我需要将64位整数（在我的例子中，这是一个无符号长long）从big endian转换为little endian。现在，我需要进行特定的转换。但是如果目标平台是WAS大端，那么函数（如ntohl()）不会转换我的64位值会更好。（我宁愿避免添加我自己的预处理器魔法来执行此操作）。

我可以使用什么？如果它存在，我想要标准的东西，但我愿意接受实施建议。我在过去使用过工会看过这种类型的转换。我想我可以拥有一个带有unsigned long long和char [8]的联合。然后相应地交换字节。（显然会在大端的平台上破解。）

Answer 1

文档：Linux上的man htobe64（glibc＆gt; = 2.9）或FreeBSD。

不幸的是，在2009年的一次尝试中，OpenBSD，FreeBSD和glibc（Linux）并没有很好地协同工作，为此创建一个（非内核API）libc标准。

目前，这一小段预处理器代码：

#if defined(__linux__)
#  include <endian.h>
#elif defined(__FreeBSD__) || defined(__NetBSD__)
#  include <sys/endian.h>
#elif defined(__OpenBSD__)
#  include <sys/types.h>
#  define be16toh(x) betoh16(x)
#  define be32toh(x) betoh32(x)
#  define be64toh(x) betoh64(x)
#endif

（在Linux和OpenBSD上测试）应该隐藏差异。它为这4个平台提供了Linux / FreeBSD风格的宏。

使用示例：

  #include <stdint.h>    // For 'uint64_t'

  uint64_t  host_int = 123;
  uint64_t  big_endian;

  big_endian = htobe64( host_int );
  host_int = be64toh( big_endian );

这是目前最“标准的C库” - 可用的方法。

Answer 2

我建议您阅读：http://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

uint64_t
ntoh64(const uint64_t *input)
{
    uint64_t rval;
    uint8_t *data = (uint8_t *)&rval;

    data[0] = *input >> 56;
    data[1] = *input >> 48;
    data[2] = *input >> 40;
    data[3] = *input >> 32;
    data[4] = *input >> 24;
    data[5] = *input >> 16;
    data[6] = *input >> 8;
    data[7] = *input >> 0;

    return rval;
}

uint64_t
hton64(const uint64_t *input)
{
    return (ntoh64(input));
}

int
main(void)
{
    uint64_t ull;

    ull = 1;
    printf("%"PRIu64"\n", ull);

    ull = ntoh64(&ull);
    printf("%"PRIu64"\n", ull);

    ull = hton64(&ull);
    printf("%"PRIu64"\n", ull);

    return 0;
}

将显示以下输出：

1
72057594037927936
1

如果丢弃高4字节，可以使用ntohl（）进行测试。

此外，你可以把它变成一个很好的模板化函数，在C ++中适用于任何大小的整数：

template <typename T>
static inline T
hton_any(const T &input)
{
    T output(0);
    const std::size_t size = sizeof(input);
    uint8_t *data = reinterpret_cast<uint8_t *>(&output);

    for (std::size_t i = 0; i < size; i++) {
        data[i] = input >> ((size - i - 1) * 8);
    }

    return output;
}

现在你的128位也是安全的！

Answer 3

要检测您的字符串，请使用以下联合：

union {
    unsigned long long ull;
    char c[8];
} x;
x.ull = 0x0123456789abcdef; // may need special suffix for ULL.

然后，您可以检查x.c[]的内容，以检测每个字节的位置。

要进行转换，我会使用该检测代码一次查看平台正在使用的字节序，然后编写我自己的函数来进行交换。

你可以让它动态化，以便代码可以在任何平台上运行（检测一次然后在转换代码中使用一个开关来选择正确的转换）但是，如果你只是要使用一个平台，我' d只需在一个单独的程序中执行一次检测，然后编写一个简单的转换例程，确保记录它只在该平台上运行（或已经过测试）。

这里有一些示例代码我掀起来说明它。它虽然没有经过彻底的测试，但应该足以让你开始。

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

#define TYP_INIT 0
#define TYP_SMLE 1
#define TYP_BIGE 2

static unsigned long long cvt(unsigned long long src) {
    static int typ = TYP_INIT;
    unsigned char c;
    union {
        unsigned long long ull;
        unsigned char c[8];
    } x;

    if (typ == TYP_INIT) {
        x.ull = 0x01;
        typ = (x.c[7] == 0x01) ? TYP_BIGE : TYP_SMLE;
    }

    if (typ == TYP_SMLE)
        return src;

    x.ull = src;
    c = x.c[0]; x.c[0] = x.c[7]; x.c[7] = c;
    c = x.c[1]; x.c[1] = x.c[6]; x.c[6] = c;
    c = x.c[2]; x.c[2] = x.c[5]; x.c[5] = c;
    c = x.c[3]; x.c[3] = x.c[4]; x.c[4] = c;
    return x.ull;
}

int main (void) {
    unsigned long long ull = 1;
    ull = cvt (ull);
    printf ("%llu\n",ull);
    return 0;
}

请记住，这只是检查纯大/小端。如果你有一些存储字节的奇怪变体，例如，{5,2,3,1,0,7,6,4}顺序，cvt()将会更复杂一些。这样的体系结构不值得存在，但我并不打算消除微处理器行业中朋友的狂热： - ）

还要记住，这是技术上未定义的行为，因为您不应该通过除最后一个字段之外的任何字段访问union成员。它可能适用于大多数实现，但是，从纯粹主义的角度来看，你应该只是咬紧牙关并使用宏来定义自己的例程，例如：

// Assumes 64-bit unsigned long long.
unsigned long long switchOrderFn (unsigned long long in) {
    in  = (in && 0xff00000000000000ULL) >> 56
        | (in && 0x00ff000000000000ULL) >> 40
        | (in && 0x0000ff0000000000ULL) >> 24
        | (in && 0x000000ff00000000ULL) >> 8
        | (in && 0x00000000ff000000ULL) << 8
        | (in && 0x0000000000ff0000ULL) << 24
        | (in && 0x000000000000ff00ULL) << 40
        | (in && 0x00000000000000ffULL) << 56;
    return in;
}
#ifdef ULONG_IS_NET_ORDER
    #define switchOrder(n) (n)
#else
    #define switchOrder(n) switchOrderFn(n)
#endif

Answer 4

某些BSD系统具有betoh64，可以满足您的需求。

Answer 5

快速回答

#include <endian.h>    // __BYTE_ORDER __LITTLE_ENDIAN
#include <byteswap.h>  // bswap_64()

uint64_t value = 0x1122334455667788;

#if __BYTE_ORDER == __LITTLE_ENDIAN
value = bswap_64(value);  // Compiler builtin GCC/Clang
#endif

头文件

正如zhaorufei所报告的那样（请参阅她/他的评论）endian.h不是C ++标准标头，宏__BYTE_ORDER和__LITTLE_ENDIAN可能未定义。因此，#if语句是不可预测的，因为未定义的宏被视为0。

如果你想分享你的C ++优雅技巧以检测字节顺序，请编辑这个答案。

可移植性

此外，宏bswap_64()可用于GCC和Clang编译器，但不适用于Visual C ++编译器。要提供便携式源代码，您可能会受到以下代码段的启发：

#ifdef _MSC_VER
  #include <stdlib.h>
  #define bswap_16(x) _byteswap_ushort(x)
  #define bswap_32(x) _byteswap_ulong(x)
  #define bswap_64(x) _byteswap_uint64(x)
#else
  #include <byteswap.h>  // bswap_16 bswap_32 bswap_64
#endif

另请参阅更便携的源代码：Cross-platform _byteswap_uint64

C ++ 14 `constexpr`模板函数

16位，32位，64位以上的通用hton() ...

#include <endian.h>   // __BYTE_ORDER __LITTLE_ENDIAN
#include <algorithm>  // std::reverse()

template <typename T>
constexpr T htonT (T value) noexcept
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
  char* ptr = reinterpret_cast<char*>(&value);
  std::reverse(ptr, ptr + sizeof(T));
#endif
  return value;
}

C ++ 11 `constexpr`模板函数

C ++ 11不允许constexpr函数中的局部变量因此，技巧是使用具有默认值的参数。
此外，C ++ 11 constexpr函数必须包含一个单独的表达式因此，正文由一个带有逗号分隔的语句的返回符组成。

template <typename T>
constexpr T htonT (T value, char* ptr=0) noexcept
{
  return 
#if __BYTE_ORDER == __LITTLE_ENDIAN
    ptr = reinterpret_cast<char*>(&value), 
    std::reverse(ptr, ptr + sizeof(T)),
#endif
    value;
}

使用-Wall -Wextra -pedantic的clang-3.5和GCC-4.9都没有编译警告（请参阅coliru上的编译和运行输出）。

C ++ 11 `constexpr`模板SFINAE函数

但是，上述版本不允许将constexpr变量创建为：

constexpr int32_t hton_six = htonT( int32_t(6) );

最后，我们需要根据16/32/64位分离（专门化）函数但我们仍然可以保留通用功能（请参阅coliru上的完整摘要）

以下C ++ 11摘要使用traits std::enable_if来利用Substitution Failure Is Not An Error（SFINAE）。

template <typename T>
constexpr typename std::enable_if<sizeof(T) == 2, T>::type
htonT (T value) noexcept
{
   return  ((value & 0x00FF) << 8)
         | ((value & 0xFF00) >> 8);
}

template <typename T>
constexpr typename std::enable_if<sizeof(T) == 4, T>::type
htonT (T value) noexcept
{
   return  ((value & 0x000000FF) << 24)
         | ((value & 0x0000FF00) <<  8)
         | ((value & 0x00FF0000) >>  8)
         | ((value & 0xFF000000) >> 24);
}

template <typename T>
constexpr typename std::enable_if<sizeof(T) == 8, T>::type
htonT (T value) noexcept
{
   return  ((value & 0xFF00000000000000ull) >> 56)
         | ((value & 0x00FF000000000000ull) >> 40)
         | ((value & 0x0000FF0000000000ull) >> 24)
         | ((value & 0x000000FF00000000ull) >>  8)
         | ((value & 0x00000000FF000000ull) <<  8)
         | ((value & 0x0000000000FF0000ull) << 24)
         | ((value & 0x000000000000FF00ull) << 40)
         | ((value & 0x00000000000000FFull) << 56);
}

或者是基于内置编译器宏的简短版本和C ++ 14语法std::enable_if_t<xxx>作为std::enable_if<xxx>::type的快捷方式：

template <typename T>
constexpr typename std::enable_if_t<sizeof(T) == 2, T>
htonT (T value) noexcept
{
    return bswap_16(value);  // __bswap_constant_16
}

template <typename T>
constexpr typename std::enable_if_t<sizeof(T) == 4, T>
htonT (T value) noexcept
{
    return bswap_32(value);  // __bswap_constant_32
}

template <typename T>
constexpr typename std::enable_if_t<sizeof(T) == 8, T>
htonT (T value) noexcept
{
    return bswap_64(value);  // __bswap_constant_64
}

第一个版本的测试代码

std::uint8_t uc = 'B';                  std::cout <<std::setw(16)<< uc <<'\n';
uc = htonT( uc );                       std::cout <<std::setw(16)<< uc <<'\n';

std::uint16_t us = 0x1122;              std::cout <<std::setw(16)<< us <<'\n';
us = htonT( us );                       std::cout <<std::setw(16)<< us <<'\n';

std::uint32_t ul = 0x11223344;          std::cout <<std::setw(16)<< ul <<'\n';
ul = htonT( ul );                       std::cout <<std::setw(16)<< ul <<'\n';

std::uint64_t uL = 0x1122334455667788; std::cout <<std::setw(16)<< uL <<'\n';
uL = htonT( uL );                      std::cout <<std::setw(16)<< uL <<'\n';

第二版的测试代码

constexpr uint8_t  a1 = 'B';               std::cout<<std::setw(16)<<a1<<'\n';
constexpr auto     b1 = htonT(a1);         std::cout<<std::setw(16)<<b1<<'\n';

constexpr uint16_t a2 = 0x1122;            std::cout<<std::setw(16)<<a2<<'\n';
constexpr auto     b2 = htonT(a2);         std::cout<<std::setw(16)<<b2<<'\n';

constexpr uint32_t a4 = 0x11223344;        std::cout<<std::setw(16)<<a4<<'\n';
constexpr auto     b4 = htonT(a4);         std::cout<<std::setw(16)<<b4<<'\n';

constexpr uint64_t a8 = 0x1122334455667788;std::cout<<std::setw(16)<<a8<<'\n';
constexpr auto     b8 = htonT(a8);         std::cout<<std::setw(16)<<b8<<'\n';

输出

               B
               B
            1122
            2211
        11223344
        44332211
1122334455667788
8877665544332211

代码生成

在线C ++编译器gcc.godbolt.org表示生成的代码。

<强> g++-4.9.2 -std=c++14 -O3

std::enable_if<(sizeof (unsigned char))==(1), unsigned char>::type htonT<unsigned char>(unsigned char):
    movl    %edi, %eax
    ret
std::enable_if<(sizeof (unsigned short))==(2), unsigned short>::type htonT<unsigned short>(unsigned short):
    movl    %edi, %eax
    rolw    $8, %ax
    ret
std::enable_if<(sizeof (unsigned int))==(4), unsigned int>::type htonT<unsigned int>(unsigned int):
    movl    %edi, %eax
    bswap   %eax
    ret
std::enable_if<(sizeof (unsigned long))==(8), unsigned long>::type htonT<unsigned long>(unsigned long):
    movq    %rdi, %rax
    bswap   %rax
    ret

<强> clang++-3.5.1 -std=c++14 -O3

std::enable_if<(sizeof (unsigned char))==(1), unsigned char>::type htonT<unsigned char>(unsigned char): # @std::enable_if<(sizeof (unsigned char))==(1), unsigned char>::type htonT<unsigned char>(unsigned char)
    movl    %edi, %eax
    retq

std::enable_if<(sizeof (unsigned short))==(2), unsigned short>::type htonT<unsigned short>(unsigned short): # @std::enable_if<(sizeof (unsigned short))==(2), unsigned short>::type htonT<unsigned short>(unsigned short)
    rolw    $8, %di
    movzwl  %di, %eax
    retq

std::enable_if<(sizeof (unsigned int))==(4), unsigned int>::type htonT<unsigned int>(unsigned int): # @std::enable_if<(sizeof (unsigned int))==(4), unsigned int>::type htonT<unsigned int>(unsigned int)
    bswapl  %edi
    movl    %edi, %eax
    retq

std::enable_if<(sizeof (unsigned long))==(8), unsigned long>::type htonT<unsigned long>(unsigned long): # @std::enable_if<(sizeof (unsigned long))==(8), unsigned long>::type htonT<unsigned long>(unsigned long)
    bswapq  %rdi
    movq    %rdi, %rax
    retq

注意：我的original answer不符合C ++ 11 - constexpr。

_{此答案位于Public Domain CC0 1.0 Universal}

Answer 6

在小端机器上进行64位交换的一行宏。

#define bswap64(y) (((uint64_t)ntohl(y)) << 32 | ntohl(y>>32))

Answer 7

uint32_t SwapShort(uint16_t a)
{
  a = ((a & 0x00FF) << 8) | ((a & 0xFF00) >> 8);
  return a;
}

uint32_t SwapWord(uint32_t a)
{
  a = ((a & 0x000000FF) << 24) |
      ((a & 0x0000FF00) <<  8) |
      ((a & 0x00FF0000) >>  8) |
      ((a & 0xFF000000) >> 24);
  return a;
}

uint64_t SwapDWord(uint64_t a)
{
  a = ((a & 0x00000000000000FFULL) << 56) | 
      ((a & 0x000000000000FF00ULL) << 40) | 
      ((a & 0x0000000000FF0000ULL) << 24) | 
      ((a & 0x00000000FF000000ULL) <<  8) | 
      ((a & 0x000000FF00000000ULL) >>  8) | 
      ((a & 0x0000FF0000000000ULL) >> 24) | 
      ((a & 0x00FF000000000000ULL) >> 40) | 
      ((a & 0xFF00000000000000ULL) >> 56);
  return a;
}

Answer 8

通用版本如何，不依赖于输入大小（上面的一些实现假设unsigned long long是64位，这不一定总是正确的）：

    // converts an arbitrary large integer (preferrably >=64 bits) from big endian to host machine endian
    template<typename T> static inline T bigen2host(const T& x)
    {
        static const int one = 1;
        static const char sig = *(char*)&one; 

        if (sig == 0) return x; // for big endian machine just return the input

        T ret;
        int size = sizeof(T);
        char* src = (char*)&x + sizeof(T) - 1;
        char* dst = (char*)&ret;

        while (size-- > 0) *dst++ = *src--;

        return ret;
    }

Answer 9

怎么样：

#define ntohll(x) ( ( (uint64_t)(ntohl( (uint32_t)((x << 32) >> 32) )) << 32) | 
    ntohl( ((uint32_t)(x >> 32)) ) )                                        
#define htonll(x) ntohll(x)

Answer 10

一种简单的方法是分别在两部分上使用ntohl：

unsigned long long htonll(unsigned long long v) {
    union { unsigned long lv[2]; unsigned long long llv; } u;
    u.lv[0] = htonl(v >> 32);
    u.lv[1] = htonl(v & 0xFFFFFFFFULL);
    return u.llv;
}

unsigned long long ntohll(unsigned long long v) {
    union { unsigned long lv[2]; unsigned long long llv; } u;
    u.llv = v;
    return ((unsigned long long)ntohl(u.lv[0]) << 32) | (unsigned long long)ntohl(u.lv[1]);
}

Answer 11

我喜欢工会的答案，非常整洁。通常情况下，我只是转换为在小端和大端之间进行转换，尽管我认为联合解决方案的分配更少，而且可能更快：

//note UINT64_C_LITERAL is a macro that appends the correct prefix
//for the literal on that platform
inline void endianFlip(unsigned long long& Value)
{
   Value=
   ((Value &   UINT64_C_LITERAL(0x00000000000000FF)) << 56) |
   ((Value &   UINT64_C_LITERAL(0x000000000000FF00)) << 40) |
   ((Value &   UINT64_C_LITERAL(0x0000000000FF0000)) << 24) |
   ((Value &   UINT64_C_LITERAL(0x00000000FF000000)) << 8)  |
   ((Value &   UINT64_C_LITERAL(0x000000FF00000000)) >> 8)  | 
   ((Value &   UINT64_C_LITERAL(0x0000FF0000000000)) >> 24) |
   ((Value &   UINT64_C_LITERAL(0x00FF000000000000)) >> 40) |
   ((Value &   UINT64_C_LITERAL(0xFF00000000000000)) >> 56);
}

然后，为了检测你是否需要在没有宏魔法的情况下进行翻转，你可以做一个类似Pax的事情，当一个短路被分配给0x0001时，它会在相对的端系统上为0x0100。

所以：

unsigned long long numberToSystemEndian
(
    unsigned long long In, 
    unsigned short SourceEndian
)
{
   if (SourceEndian != 1)
   {
      //from an opposite endian system
      endianFlip(In);
   }
   return In;
}

所以要使用它，你需要SourceEndian作为一个指示器来传达输入数字的字节顺序。这可以存储在文件中（如果这是序列化问题），或通过网络传送（如果是网络序列化问题）。

Answer 12

htonl可以通过以下步骤完成

如果它的大端系统直接返回值。无需进行任何转换。如果是litte endian系统，需要做以下转换。
取LSB 32位并应用'htonl'并移位32次。
取MSB 32位（将uint64_t值右移32次）并应用'htonl'
现在对第2步和第3步中收到的值应用逐位OR。

同样适用于ntohll

#define HTONLL(x) ((1==htonl(1)) ? (x) : (((uint64_t)htonl((x) & 0xFFFFFFFFUL)) << 32) | htonl((uint32_t)((x) >> 32)))
#define NTOHLL(x) ((1==ntohl(1)) ? (x) : (((uint64_t)ntohl((x) & 0xFFFFFFFFUL)) << 32) | ntohl((uint32_t)((x) >> 32)))

你也可以将2以上的定义作为函数。

Answer 13

template <typename T>
static T ntoh_any(T t)
{
    static const unsigned char int_bytes[sizeof(int)] = {0xFF};
    static const int msb_0xFF = 0xFF << (sizeof(int) - 1) * CHAR_BIT;
    static bool host_is_big_endian = (*(reinterpret_cast<const int *>(int_bytes)) & msb_0xFF ) != 0;
    if (host_is_big_endian) { return t; }

    unsigned char * ptr = reinterpret_cast<unsigned char *>(&t);
    std::reverse(ptr, ptr + sizeof(t) );
    return t;
}

适用于2个字节，4个字节，8个字节和16个字节（如果您有128位整数）。应该是OS /平台独立的。

Answer 14

假设您使用64位操作系统在Linux上进行编码;大多数系统都有htole(x)或ntobe(x)等，这些通常是各种bswap的宏

#include <endian.h>
#include <byteswap.h>

unsigned long long htonll(unsigned long long val)
{
    if (__BYTE_ORDER == __BIG_ENDIAN) return (val);
    else return __bswap_64(val);
}

unsigned long long ntohll(unsigned long long val)
{
    if (__BYTE_ORDER == __BIG_ENDIAN) return (val);
    else return __bswap_64(val);
}

旁注;这些只是调用交换字节顺序的函数。如果您使用小端，例如使用大端网络，但如果您使用大结尾编码，那么这将不必要地反转字节顺序，因此可能需要进行一些“if __BYTE_ORDER == __LITTLE_ENDIAN”检查以使您的代码更具可移植性，取决于你的需求。

更新：编辑以显示结束检查的示例

Answer 15

任何值大小的通用函数。

template <typename T>
T swap_endian (T value)
{
    union {
        T src;
        unsigned char dst[sizeof(T)];
    } source, dest;

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

    return dest.src;
}

Answer 16

union help64
{
    unsigned char byte[8];
    uint64_t quad;
};
uint64_t ntoh64(uint64_t src)
{
    help64 tmp;
    tmp.quad = src;
    uint64_t dst = 0;
    for(int i = 0; i < 8; ++i)
        dst = (dst << 8) + tmp.byte[i];
    return dst;
}

Answer 17

通常不需要知道将主机整数转换为网络顺序的机器的字节顺序。不幸的是，只有在以字节为单位写出网络顺序值而不是另一个整数时才会成立：

static inline void short_to_network_order(uchar *output, uint16_t in)
{
    output[0] = in>>8&0xff;
    output[1] = in&0xff;
}

（根据较大数字的要求延伸）。

这将（a）在任何架构上工作，因为在任何时候我都不会使用关于整数在内存中布局的方式的特殊知识，而且（b）应该主要在大端架构中进行优化，因为现代编译器不是愚蠢。

当然，缺点是这与htonl（）和朋友的标准界面不一样（我认为这不是一个缺点，因为htonl（）的设计是一个糟糕的选择imo）。

C ++中的64位ntohl（）？

17 个答案:

快速回答

头文件

可移植性

C ++ 14 `constexpr`模板函数

C ++ 11 `constexpr`模板函数

C ++ 11 `constexpr`模板SFINAE函数

第一个版本的测试代码

第二版的测试代码

输出

代码生成

C ++中的64位ntohl（）？

17 个答案:

快速回答

头文件

可移植性

C ++ 14 constexpr模板函数

C ++ 11 constexpr模板函数

C ++ 11 constexpr模板SFINAE函数

第一个版本的测试代码

第二版的测试代码

输出

代码生成

C ++ 14 `constexpr`模板函数

C ++ 11 `constexpr`模板函数

C ++ 11 `constexpr`模板SFINAE函数