在模板函数中围绕枢轴使用老式的3-step-xor技巧进行字节交换，提供了一个灵活、快速的O(ln2)解决方案，不需要库，这里的风格也拒绝1字节类型:

template<typename T>void swap(T &t){
    for(uint8_t pivot = 0; pivot < sizeof(t)/2; pivot ++){
        *((uint8_t *)&t + pivot) ^= *((uint8_t *)&t+sizeof(t)-1- pivot);
        *((uint8_t *)&t+sizeof(t)-1- pivot) ^= *((uint8_t *)&t + pivot);
        *((uint8_t *)&t + pivot) ^= *((uint8_t *)&t+sizeof(t)-1- pivot);
    }
}

我最近写了一个宏来在C中实现这个功能，但它在c++中同样有效:

#define REVERSE_BYTES(...) do for(size_t REVERSE_BYTES=0; REVERSE_BYTES<sizeof(__VA_ARGS__)>>1; ++REVERSE_BYTES)\
    ((unsigned char*)&(__VA_ARGS__))[REVERSE_BYTES] ^= ((unsigned char*)&(__VA_ARGS__))[sizeof(__VA_ARGS__)-1-REVERSE_BYTES],\
    ((unsigned char*)&(__VA_ARGS__))[sizeof(__VA_ARGS__)-1-REVERSE_BYTES] ^= ((unsigned char*)&(__VA_ARGS__))[REVERSE_BYTES],\
    ((unsigned char*)&(__VA_ARGS__))[REVERSE_BYTES] ^= ((unsigned char*)&(__VA_ARGS__))[sizeof(__VA_ARGS__)-1-REVERSE_BYTES];\
while(0)

它接受任何类型，并反转传入参数中的字节。 示例用法:

int main(){
    unsigned long long x = 0xABCDEF0123456789;
    printf("Before: %llX\n",x);
    REVERSE_BYTES(x);
    printf("After : %llX\n",x);

    char c[7]="nametag";
    printf("Before: %c%c%c%c%c%c%c\n",c[0],c[1],c[2],c[3],c[4],c[5],c[6]);
    REVERSE_BYTES(c);
    printf("After : %c%c%c%c%c%c%c\n",c[0],c[1],c[2],c[3],c[4],c[5],c[6]);
}

打印:

Before: ABCDEF0123456789
After : 8967452301EFCDAB
Before: nametag
After : gateman

上面的内容是完全可以复制/粘贴的，但这里有很多内容，所以我将逐条分解它的工作原理:

第一件值得注意的事情是整个宏被封装在一个do while(0)块中。这是一种常见的习惯用法，允许在宏后面使用正常的分号。

接下来是使用名为REVERSE_BYTES的变量作为for循环的计数器。宏本身的名称用作变量名，以确保它不会与范围内的任何其他符号冲突。由于该名称是在宏的展开中使用的，因此在这里作为变量名使用时不会再次展开。

在for循环中，有两个字节被引用并交换了XOR(因此不需要临时变量名):

((unsigned char*)&(__VA_ARGS__))[REVERSE_BYTES]
((unsigned char*)&(__VA_ARGS__))[sizeof(__VA_ARGS__)-1-REVERSE_BYTES]

__VA_ARGS__表示给宏的任何内容，并用于增加可能传入内容的灵活性(尽管不是很多)。然后，该参数的地址被转换为unsigned char指针，以允许通过数组[]下标交换其字节。

最后一个特殊之处是缺少{}大括号。它们不是必需的，因为每次交换中的所有步骤都使用逗号操作符连接，使它们成为一条语句。

最后，值得注意的是，如果速度是最优先考虑的，这不是理想的方法。如果这是一个重要因素，那么其他答案中引用的一些特定于类型的宏或特定于平台的指令可能是更好的选择。然而，这种方法可以移植到所有类型、所有主要平台以及C和c++语言。

简单地说:

#include <climits>

template <typename T>
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 < uint32_t >(42)。

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

如果一个大端位32位无符号整数看起来像0xAABBCCDD，它等于2864434397，那么同样的32位无符号整数在小端位处理器上看起来像0xDDCCBBAA，它也等于2864434397。

如果一个大端序16位无符号空头看起来像0xAABB，它等于43707，那么同一个16位无符号空头在小端序处理器上看起来像0xBBAA，它也等于43707。

这里有两个方便的#define函数，用于将字节从小端序转换为大端序，反之亦然——>

// can be used for short, unsigned short, word, unsigned word (2-byte types)
#define BYTESWAP16(n) (((n&0xFF00)>>8)|((n&0x00FF)<<8))

// can be used for int or unsigned int or float (4-byte types)
#define BYTESWAP32(n) ((BYTESWAP16((n&0xFFFF0000)>>16))|((BYTESWAP16(n&0x0000FFFF))<<16))

// can be used for unsigned long long or double (8-byte types)
#define BYTESWAP64(n) ((BYTESWAP32((n&0xFFFFFFFF00000000)>>32))|((BYTESWAP32(n&0x00000000FFFFFFFF))<<32))

认真……我不明白为什么所有的解决方案都那么复杂!最简单、最通用的模板函数如何?它可以在任何操作系统的任何情况下交换任何大小的任何类型????

template <typename T>
void SwapEnd(T& var)
{
    static_assert(std::is_pod<T>::value, "Type must be POD type for safety");
    std::array<char, sizeof(T)> varArray;
    std::memcpy(varArray.data(), &var, sizeof(T));
    for(int i = 0; i < static_cast<int>(sizeof(var)/2); i++)
        std::swap(varArray[sizeof(var) - 1 - i],varArray[i]);
    std::memcpy(&var, varArray.data(), sizeof(T));
}

这是C和c++结合的神奇力量!只需逐个字符交换原始变量。

要点1:没有操作符:请记住，我没有使用简单的赋值操作符“=”，因为当反转字节序时，一些对象将被打乱，复制构造函数(或赋值操作符)将不起作用。因此，一个字符一个字符地复制它们更加可靠。

Point 2: Be aware of alignment issues: Notice that we're copying to and from an array, which is the right thing to do because the C++ compiler doesn't guarantee that we can access unaligned memory (this answer was updated from its original form for this). For example, if you allocate uint64_t, your compiler cannot guarantee that you can access the 3rd byte of that as a uint8_t. Therefore, the right thing to do is to copy this to a char array, swap it, then copy it back (so no reinterpret_cast). Notice that compilers are mostly smart enough to convert what you did back to a reinterpret_cast if they're capable of accessing individual bytes regardless of alignment.

使用此函数:

double x = 5;
SwapEnd(x);

现在x的字节序不同了。