如何将两个uint32变量转为小端序uint8数组并传入指定函数？

问题澄清 #

你提到要采用小端序，但给出的期望输出是[0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0]，这其实是**大端序（高位字节在前）**的结果。小端序的正确输出应该是[0x78, 0x56, 0x34, 0x12, 0xF0, 0xDE, 0xBC, 0x9A]（低位字节在前）。下面会同时给出两种顺序的实现方案，你可以根据实际需求选择。

栈溢出原因 #

你遇到的*** stack smashing detected ***错误，几乎可以肯定是因为存储转换结果的数组长度不足：比如只声明了4字节的数组，却试图写入两个uint32的8字节数据，导致越界覆盖栈内存，触发系统的栈保护机制。解决的核心是确保数组大小足够容纳8个uint8元素。

实现方案 #

方案1：手动移位（不受系统字节序影响，严格控制顺序） #

这种方式最直观，不依赖系统字节序，适合需要严格指定字节顺序的场景。

代码示例（按你期望的大端序）

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

void func(uint8_t *result) {
    // 示例函数：打印转换后的字节数组
    for (int i = 0; i < 8; i++) {
        printf("0x%02X ", result[i]);
    }
    putchar('\n');
}

int main() {
    uint32_t var1 = 0x12345678;
    uint32_t var2 = 0x9ABCDEF0;
    uint8_t buf[8]; // 必须分配足够的内存，8字节刚好容纳两个uint32

    // 处理第一个uint32：高位字节在前
    buf[0] = (var1 >> 24) & 0xFF;
    buf[1] = (var1 >> 16) & 0xFF;
    buf[2] = (var1 >> 8) & 0xFF;
    buf[3] = var1 & 0xFF;

    // 处理第二个uint32：同样高位字节在前
    buf[4] = (var2 >> 24) & 0xFF;
    buf[5] = (var2 >> 16) & 0xFF;
    buf[6] = (var2 >> 8) & 0xFF;
    buf[7] = var2 & 0xFF;

    func(buf); // 传入转换后的数组
    return 0;
}

小端序版本调整

如果确实需要小端序，只需调整字节写入的顺序：

// 处理第一个uint32：低位字节在前（小端序）
buf[0] = var1 & 0xFF;
buf[1] = (var1 >> 8) & 0xFF;
buf[2] = (var1 >> 16) & 0xFF;
buf[3] = (var1 >> 24) & 0xFF;

// 处理第二个uint32：同样低位字节在前（小端序）
buf[4] = var2 & 0xFF;
buf[5] = (var2 >> 8) & 0xFF;
buf[6] = (var2 >> 16) & 0xFF;
buf[7] = (var2 >> 24) & 0xFF;

方案2：封装通用转换函数（代码更简洁） #

如果需要多次转换，可以把单个uint32转字节数组的逻辑封装成函数，复用性更强：

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

void func(uint8_t *result) {
    for (int i = 0; i < 8; i++) {
        printf("0x%02X ", result[i]);
    }
    putchar('\n');
}

// 将uint32转换为4字节数组，is_big_endian=1表示大端，0表示小端
void uint32_to_bytes(uint32_t val, uint8_t *dest, int is_big_endian) {
    if (is_big_endian) {
        dest[0] = (val >> 24) & 0xFF;
        dest[1] = (val >> 16) & 0xFF;
        dest[2] = (val >> 8) & 0xFF;
        dest[3] = val & 0xFF;
    } else {
        dest[0] = val & 0xFF;
        dest[1] = (val >> 8) & 0xFF;
        dest[2] = (val >> 16) & 0xFF;
        dest[3] = (val >> 24) & 0xFF;
    }
}

int main() {
    uint32_t var1 = 0x12345678;
    uint32_t var2 = 0x9ABCDEF0;
    uint8_t buf[8];

    // 转换第一个变量到buf前4字节（大端序）
    uint32_to_bytes(var1, buf, 1);
    // 转换第二个变量到buf后4字节（大端序）
    uint32_to_bytes(var2, buf + 4, 1);

    func(buf);
    return 0;
}

方案3：使用memcpy（依赖系统字节序） #

如果你的系统字节序刚好符合需求，可以直接用memcpy拷贝内存，但这种方式不跨平台，需谨慎使用：

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

void func(uint8_t *result) {
    for (int i = 0; i < 8; i++) {
        printf("0x%02X ", result[i]);
    }
    putchar('\n');
}

int main() {
    uint32_t var1 = 0x12345678;
    uint32_t var2 = 0x9ABCDEF0;
    uint8_t buf[8];

    // 如果系统是大端序，直接拷贝即可得到你期望的结果
    memcpy(buf, &var1, sizeof(var1));
    memcpy(buf + sizeof(var1), &var2, sizeof(var2));

    func(buf);
    return 0;
}

注意：如果系统是小端序，这种方式得到的是小端序的数组，若需要大端序则需要额外反转字节顺序。

内容的提问来源于stack exchange，提问作者user20156410