C++结构体大小端 字节序敏感数据处理

int

long

float

double

int

0x12345678

0x78563412

int

0x12345678

78 56 34 12

78

12

0x78563412

#include <iostream>

bool is_little_endian() {
    union {
        short s;
        char c[sizeof(short)];
    } un;
    un.s = 0x0100; // 假设我们赋值一个16位的short，高位是1，低位是0
                   // 在大端系统上，内存是 01 00
                   // 在小端系统上，内存是 00 01
    return (un.c[0] == 0x00); // 如果第一个字节是00，说明是小端
}

int main() {
    if (is_little_endian()) {
        std::cout << "当前系统是小端模式 (Little-Endian)." << std::endl;
    } else {
        std::cout << "当前系统是大端模式 (Big-Endian)." << std::endl;
    }
    return 0;
}

short

0x0100

un.c[0]

std::endian

#include <iostream>
#include <endian> // C++20 header

int main() {
    if (std::endian::native == std::endian::little) {
        std::cout << "当前系统是小端模式 (Little-Endian) (C++20)." << std::endl;
    } else if (std::endian::native == std::endian::big) {
        std::cout << "当前系统是大端模式 (Big-Endian) (C++20)." << std::endl;
    } else {
        std::cout << "当前系统是混合端模式 (Mixed-Endian) (C++20)." << std::endl;
    }
    return 0;
}

std::endian

if (is_little_endian())

long long

float

double

#include <cstdint> // For uint64_t
#include <algorithm> // For std::reverse

// 假设我们有一个通用的字节序翻转函数
uint64_t swap_endian_64(uint64_t value) {
    uint8_t bytes[8];
    // 将uint64_t分解为8个字节
    for (int i = 0; i < 8; ++i) {
        bytes[i] = (value >> (i * 8)) & 0xFF;
    }
    // 翻转字节顺序
    std::reverse(bytes, bytes + 8);
    // 重新组合成uint64_t
    uint64_t result = 0;
    for (int i = 0; i < 8; ++i) {
        result |= (static_cast<uint64_t>(bytes[i]) << (i * 8));
    }
    return result;
}

// 示例：将主机字节序的64位整数转换为网络字节序（大端）
uint64_t host_to_network_64(uint64_t host_val) {
    // 假设is_little_endian()是前面定义的检测函数
    if (is_little_endian()) {
        return swap_endian_64(host_val);
    }
    return host_val; // 如果已经是大端，则无需转换
}

// 示例：将网络字节序的64位整数转换为主机字节序
uint64_t network_to_host_64(uint64_t net_val) {
    if (is_little_endian()) {
        return swap_endian_64(net_val);
    }
    return net_val;
}

float

double

uint32_t

uint64_t

memcpy

#include <iostream>
#include <arpa/inet.h> // For htonl, ntohl (Linux/Unix)
// For Windows, use <winsock2.h> and link with ws2_32.lib

// 假设我们的协议定义了一个这样的数据包
struct MyPacket {
    uint32_t id;
    uint16_t type;
    float value; // 浮点数通常也需要特殊处理
    // ... 其他字段
};

// 浮点数字节序转换示例 (仅作演示，实际应用可能需要更健壮的实现)
float swap_endian_float(float f) {
    uint32_t val;
    std::memcpy(&val, &f, sizeof(float)); // 将浮点数位模式拷贝到整数
    val = htonl(val); // 转换整数的字节序
    std::memcpy(&f, &val, sizeof(float)); // 再拷贝回浮点数
    return f;
}

// 发送前将结构体转换为网络字节序
void to_network_order(MyPacket& packet) {
    packet.id = htonl(packet.id);
    packet.type = htons(packet.type);
    packet.value = swap_endian_float(packet.value);
    // ... 其他字段
}

// 接收后将结构体从网络字节序转换为主机字节序
void from_network_order(MyPacket& packet) {
    packet.id = ntohl(packet.id);
    packet.type = ntohs(packet.type);
    packet.value = swap_endian_float(packet.value); // 浮点数转换是双向的
    // ... 其他字段
}

int main() {
    MyPacket p = {12345, 100, 3.14f};
    std::cout << "原始数据: id=" << p.id << ", type=" << p.type << ", value=" << p.value << std::endl;

    to_network_order(p);
    std::cout << "转换为网络字节序后: id=" << p.id << ", type=" << p.type << ", value=" << p.value << std::endl;
    // 此时打印出来的id和type可能看起来是乱码，因为它们已经是网络字节序了

    // 模拟接收方，再转换回来
    from_network_order(p);
    std::cout << "从网络字节序转换回来后: id=" << p.id << ", type=" << p.type << ", value=" << p.value << std::endl;

    return 0;
}