std::byteswap(C++23) ​

什么是 std::byteswap ​

std::byteswap 是 C++23 引入的函数模板,定义在 <bit> 头文件中。它将一个整数值的字节顺序反转——第一个字节和最后一个字节交换,第二个字节和倒数第二个字节交换,以此类推。

这个函数最常见的用途是在小端序和大端序之间转换整数数据,比如网络编程中的字节序转换、读取跨平台二进制文件等。

cpp
#include <bit>
#include <cstdint>

uint32_t value = 0x12345678;
uint32_t swapped = std::byteswap(value);  // 0x78563412

基本示例 ​

cpp
#include <iostream>
#include <bit>
#include <cstdint>
#include <iomanip>
#include <array>
#include <vector>

// ============================
// 示例1:各种整数类型的字节交换
// ============================

void basic_demo() {
    // 16 位
    std::uint16_t u16 = 0xCAFE;
    std::cout << "uint16: 0x" << std::hex
              << u16 << " -> 0x" << std::byteswap(u16) << std::endl;
    // 0xCAFE -> 0xFECA

    // 32 位
    std::uint32_t u32 = 0xDEADBEEF;
    std::cout << "uint32: 0x" << u32 << " -> 0x"
              << std::byteswap(u32) << std::endl;
    // 0xDEADBEEF -> 0xEFBEADDE

    // 64 位
    std::uint64_t u64 = 0x0123456789ABCDEFull;
    std::cout << "uint64: 0x" << u64 << " -> 0x"
              << std::byteswap(u64) << std::dec << std::endl;
    // 0x0123456789ABCDEF -> 0xEFCDAB8967452301
}

// ============================
// 示例2:constexpr 编译期使用
// ============================

void constexpr_demo() {
    constexpr std::uint32_t original = 0x12345678;
    constexpr std::uint32_t swapped = std::byteswap(original);

    // 编译期验证
    static_assert(swapped == 0x78563412);
    static_assert(std::byteswap(swapped) == original);  // 交换两次恢复原值

    std::cout << "编译期交换: 0x" << std::hex << original
              << " -> 0x" << swapped << std::dec << std::endl;
}

// ============================
// 示例3:单字节类型
// ============================

void single_byte_demo() {
    // 单字节类型交换后不变
    std::uint8_t byte = 0xAB;
    auto swapped = std::byteswap(byte);

    std::cout << "uint8: 0x" << std::hex << (int)byte
              << " -> 0x" << (int)swapped << std::dec << std::endl;
    // 0xAB -> 0xAB(不变)

    static_assert(std::byteswap('a') == 'a');
}

// ============================
// 示例4:网络字节序转换
// ============================

// 将主机字节序转为网络字节序(大端序)
constexpr std::uint32_t hton32(std::uint32_t host) {
    if constexpr (std::endian::native == std::endian::big) {
        return host;  // 已经是大端序
    } else {
        return std::byteswap(host);  // 小端序转大端序
    }
}

// 将网络字节序转为主机字节序
constexpr std::uint32_t ntoh32(std::uint32_t net) {
    return hton32(net);  // 操作是对称的
}

constexpr std::uint16_t hton16(std::uint16_t host) {
    if constexpr (std::endian::native == std::endian::big) {
        return host;
    } else {
        return std::byteswap(host);
    }
}

void network_demo() {
    // 模拟 IP 地址 192.168.1.100
    std::uint32_t ip = (192u << 24) | (168u << 16) | (1u << 8) | 100u;
    std::uint32_t net_ip = hton32(ip);

    std::cout << "主机序 IP: 0x" << std::hex << ip << std::endl;
    std::cout << "网络序 IP: 0x" << net_ip << std::dec << std::endl;

    // 端口号
    std::uint16_t port = 8080;
    std::uint16_t net_port = hton16(port);
    std::cout << "主机序端口: " << port << std::endl;
    std::cout << "网络序端口: " << net_port << std::endl;
}

// ============================
// 示例5:有符号整数
// ============================

void signed_demo() {
    // byteswap 也可以用于有符号整数
    std::int32_t value = -1;  // 0xFFFFFFFF(补码)
    auto swapped = std::byteswap(value);

    std::cout << "int32 -1: 0x" << std::hex
              << static_cast<std::uint32_t>(value)
              << " -> 0x" << static_cast<std::uint32_t>(swapped)
              << std::dec << std::endl;
    // 0xFFFFFFFF -> 0xFFFFFFFF(全1交换后仍是全1)

    std::int16_t v2 = 256;  // 0x0100
    auto s2 = std::byteswap(v2);
    std::cout << "int16 256(0x0100) -> " << s2 << "(0x"
              << std::hex << static_cast<std::uint16_t>(s2)
              << ")" << std::dec << std::endl;
    // 256(0x0100) -> 1(0x0001)
}

// ============================
// 示例6:读取二进制文件中的跨平台数据
// ============================

struct FileHeader {
    std::uint32_t magic;
    std::uint32_t version;
    std::uint32_t data_size;
};

// 假设文件以大端序存储
FileHeader read_header_big_endian(const std::uint8_t* data) {
    FileHeader header;
    std::memcpy(&header, data, sizeof(header));

    // 如果当前平台是小端序,需要转换
    if constexpr (std::endian::native == std::endian::little) {
        header.magic = std::byteswap(header.magic);
        header.version = std::byteswap(header.version);
        header.data_size = std::byteswap(header.data_size);
    }

    return header;
}

void file_demo() {
    // 模拟大端序存储的文件头
    std::uint8_t raw[] = {
        0x89, 0x50, 0x4E, 0x47,  // magic: 0x89504E47
        0x00, 0x00, 0x00, 0x01,  // version: 1
        0x00, 0x01, 0x00, 0x00,  // data_size: 65536
    };

    auto header = read_header_big_endian(raw);
    std::cout << "magic: 0x" << std::hex << header.magic << std::dec << std::endl;
    std::cout << "version: " << header.version << std::endl;
    std::cout << "data_size: " << header.data_size << std::endl;
}

int main() {
    std::cout << "=== 基本交换 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== constexpr ===" << std::endl;
    constexpr_demo();

    std::cout << "\n=== 单字节 ===" << std::endl;
    single_byte_demo();

    std::cout << "\n=== 网络字节序 ===" << std::endl;
    network_demo();

    std::cout << "\n=== 有符号整数 ===" << std::endl;
    signed_demo();

    std::cout << "\n=== 二进制文件 ===" << std::endl;
    file_demo();

    return 0;
}

byteswap vs 传统方式 ​

方式标准constexpr可读性备注
std::byteswapC++23是好推荐
手动位移所有版本是差容易出错
__builtin_bswap32GCC/Clang否中等不可移植
_byteswap_ulongMSVC否中等不可移植
htonl/ntohlPOSIX否中等只支持32位

适用场景 ​

  • 网络编程中的字节序转换
  • 读写跨平台二进制文件
  • 与大端序硬件设备通信
  • 协议解析中的字段转换
  • 替代平台特定的字节交换内建函数

常见问题 ​

byteswap 只能用于整数类型吗?

是的。byteswap 只接受整数类型(integral types),包括 char、short、int、long、long long 及其无符号版本。不能用于 float、double 或自定义类型。

交换两次会恢复原值吗?

是的。byteswap(byteswap(x)) == x 对所有整数值成立。

byteswap 有性能开销吗?

现代编译器通常会将 byteswap 编译为单条 CPU 指令(如 x86 的 BSWAP),性能开销极小。

注意事项 ​

  • 只接受整数类型,不能用于浮点数
  • T 不能有填充位(padding bits)
  • 单字节类型交换后值不变
  • 交换操作是对称的——交换两次恢复原值
  • 需要 <bit> 头文件

总结 ​

std::byteswap 是 C++23 引入的标准字节序交换函数,将整数的字节顺序反转。它替代了以前需要手动位移或使用平台特定内建函数的做法,提供了统一、可移植、constexpr 的解决方案。配合 std::endian 使用,可以编写简洁的跨平台字节序转换代码。典型应用场景包括网络编程、二进制文件读写和硬件通信。