使用共用体检测系统大小端

#include <stdio.h>
#include <stdint.h>//包含uint32_t 定义

// 定义一个共用体，包含一个32位整数和一个字节数组
union EndiannessChecker {
    uint32_t intValue;
    uint8_t byteArray[4]; // 4字节的整数需要4字节的数组来表示
};

int main() {
    union EndiannessChecker checker;
    checker.intValue = 0x12345678; // 将一个整数值存储到共用体的intValue字段中

    // 如果系统是小端字节序，则最低地址处存储最低有效字节
    if (checker.byteArray[0] == 0x78) {
        printf("系统采用小端字节序（Little Endian）\n");
    }
    // 如果系统是大端字节序，则最低地址处存储最高有效字节
    else if (checker.byteArray[0] == 0x12) {
        printf("系统采用大端字节序（Big Endian）\n");
    }
    else {
        printf("无法确定系统字节序\n");
    }
    return 0;
}

使用memcpy进行数组数据拼接

• 多个数组拼接为一个数组

#include <stdio.h>
#include <string.h> // 包含 memcpy 函数的头文件

int main() {
    int arr1[] = {1, 2, 3};
    int arr2[] = {4, 5, 6};
    int len1 = sizeof(arr1) / sizeof(arr1[0]);
    int len2 = sizeof(arr2) / sizeof(arr2[0]);
    
    int result[len1 + len2];
    
    // 使用 memcpy 将第一个数组拷贝到结果数组
    memcpy(result, arr1, len1 * sizeof(int));
    
    // 使用 memcpy 将第二个数组拷贝到结果数组
    memcpy(result + len1, arr2, len2 * sizeof(int));
    
    // 打印拼接后的数组
    for (int i = 0; i < len1 + len2; i++) {
        printf("%d ", result[i]);
    }
    
    return 0;
}

• 多个少位数组拼接为一个多位数据

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

int main() {
    uint8_t array1[4] = {0x12, 0x34, 0x56, 0x78}; // 4个8位数组
    uint32_t result = 0; // 初始化32位结果为0

    // 将4个8位数组的值拼接为一个32位整数
    for (int i = 0; i < 4; i++) {
        result = (result << 8) | array1[i];
    }

    // 打印拼接后的32位整数
    printf("拼接后的32位整数：0x%08x\n", result);

    return 0;
}

多机大小端匹配

#include <stdio.h>
#include <stdint.h>
#include <arpa/inet.h> // 包含字节序转换函数

int main() {
    uint32_t hostValue = 0x12345678; // 假设一个整数值

    // 主机字节顺序（可能是大端或小端）到网络字节序的转换
    uint32_t networkValue = htonl(hostValue);

    // 打印转换后的网络字节序值
    printf("Network Byte Order: 0x%08x\n", networkValue);

    // 再次将网络字节序转换为主机字节顺序
    uint32_t hostValueRestored = ntohl(networkValue);

    // 打印还原后的值
    printf("Host Byte Order Restored: 0x%08x\n", hostValueRestored);

    return 0;
}

• 有些编译器不支持网络编程，以下为htohl与ntohl函数实现

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

uint32_t htonl(uint32_t hostlong) {
    // 定义一个变量来存储转换后的网络字节序值
    uint32_t networklong = 0;

    // 将主机字节序的32位整数按字节逐个拷贝到网络字节序的变量中
    networklong |= (hostlong & 0xFF) << 24;        // 最高字节
    networklong |= ((hostlong >> 8) & 0xFF) << 16; // 次高字节
    networklong |= ((hostlong >> 16) & 0xFF) << 8; // 次低字节
    networklong |= (hostlong >> 24) & 0xFF;        // 最低字节

    return networklong;
}

uint32_t ntohl(uint32_t netlong) {
    // 定义一个变量来存储转换后的主机字节序值
    uint32_t hostlong = 0;

    // 将网络字节序的32位整数按字节逐个拷贝到主机字节序的变量中
    hostlong |= (netlong & 0xFF) << 24;            // 最高字节
    hostlong |= ((netlong >> 8) & 0xFF) << 16;     // 次高字节
    hostlong |= ((netlong >> 16) & 0xFF) << 8;     // 次低字节
    hostlong |= (netlong >> 24) & 0xFF;            // 最低字节

    return hostlong;
}


int main() {
    uint32_t hostValue = 0x12345678; // 假设一个整数值

    // 主机字节顺序（可能是大端或小端）到网络字节序的转换
    uint32_t networkValue = htonl(hostValue);

    // 打印转换后的网络字节序值
    printf("Network Byte Order: 0x%08x\n", networkValue);

    // 再次将网络字节序转换为主机字节顺序
    uint32_t hostValueRestored = ntohl(networkValue);

    // 打印还原后的值
    printf("Host Byte Order Restored: 0x%08x\n", hostValueRestored);

    return 0;
}

共用体进行大小端切换

#include <stdio.h>

union EndianConverter {
    unsigned int integer;
    unsigned char bytes[4];
};

int main() {
    union EndianConverter converter;
    
    converter.integer = 0x12345678;  // 一个32位整数的示例值
    
    printf("原始数据：0x%08X\n", converter.integer);
    
    // 切换大小端
    unsigned int bigEndianValue = 
        (converter.bytes[0] << 24) |
        (converter.bytes[1] << 16) |
        (converter.bytes[2] << 8) |
        converter.bytes[3];
    
    printf("切换为Big Endian：0x%08X\n", bigEndianValue);
    
    // 再切换回Little Endian
    converter.integer =
        (bigEndianValue >> 24) |
        ((bigEndianValue >> 16) & 0xFF00) |
        ((bigEndianValue >> 8) & 0xFF0000) |
        (bigEndianValue << 24);
    
    printf("切换回Little Endian：0x%08X\n", converter.integer);
    
    return 0;
}