我已经搜索了许多站点,但似乎找不到任何相关的内容。

我希望能够获取每种默认数据类型(例如short,unsigned short,int,unsigned int,float和double)的各个字节,并将每个单独的字节信息(二进制部分)存储到unsigned char的每个索引中数组。如何做到这一点?

例如:

int main() {
    short sVal = 1;
    unsigned short usVal = 2;
    int iVal = 3;
    unsigned int uiVal = 4;
    float fVal = 5.0f;
    double dVal = 6.0;

    const unsigned int uiLengthOfShort  = sizeof(short);
    const unsigned int uiLengthOfUShort = sizeof(unsigned short);
    const unsigned int uiLengthOfInt    = sizeof(int);
    const unsigned int uiLengthOfUInt   = sizeof(unsigned int);
    const unsigned int uiLengthOfFloat  = sizeof(float);
    const unsigned int uiLengthOfDouble = sizeof(double);

    unsigned char ucShort[uiLengthOfShort];
    unsigned char ucUShort[uiLengthOfUShort];
    unsigned char ucInt[uiLengthOfInt];
    unsigned char ucUInt[uiLengthOfUInt];
    unsigned char ucFloat[uiLengthOfFloat];
    unsigned char ucDouble[uiLengthOfDouble];

    // Above I declared a variable val for each data type to work with
    // Next I created a const unsigned int of each type's size.
    // Then I created unsigned char[] using each data types size respectively
    // Now I would like to take each individual byte of the above val's
    // and store them into the indexed location of each unsigned char array.

    // For Example: - I'll not use int here since the int is
    // machine and OS dependent.
    // I will use a data type that is common across almost all machines.
    // Here I will use the short as my example

    // We know that a short is 2-bytes or has 16 bits encoded
    // I would like to take the 1st byte of this short:
    // (the first 8 bit sequence) and to store it into the first index of my unsigned char[].
    // Then I would like to take the 2nd byte of this short:
    // (the second 8 bit sequence) and store it into the second index of my unsigned char[].

    // How would this be achieved for any of the data types?

    // A Short in memory is 2 bytes here is a bit representation of an
    // arbitrary short in memory { 0101 1101, 0011 1010 }
    // I would like ucShort[0] = sVal's { 0101 1101 } &
    //              ucShort[1] = sVal's { 0011 1010 }

    ucShort[0] = sVal's First Byte info. (8 Bit sequence)
    ucShort[1] = sVal's Second Byte info. (8 Bit sequence)

    // ... and so on for each data type.

    return 0;
}

最佳答案

好的,所以首先,如果可以避免就不要这样做。它很危险,并且可能非常依赖于体系结构。

上面的注释者是正确的,联合是最安全的方法,仍然存在字节序问题,是的,但是至少您没有堆栈对齐问题(我假设这是针对网络代码的,所以堆栈对齐是另一个潜在的架构问题)

这是我发现的最简单的方法:

uint32_t example_int;
char array[4];

//No endian switch
array[0] = ((char*) &example_int)[0];
array[1] = ((char*) &example_int)[1];
array[2] = ((char*) &example_int)[2];
array[3] = ((char*) &example_int)[3];

//Endian switch
array[0] = ((char*) &example_int)[3];
array[1] = ((char*) &example_int)[2];
array[2] = ((char*) &example_int)[1];
array[3] = ((char*) &example_int)[0];


如果您尝试编写跨体系结构代码,则需要以一种或另一种方式处理字节序问题。我的建议是构造一个短字节序测试,并根据上述方法构建函数以“打包”和“解包”字节数组。应当注意,要“解包”字节数组,只需反转上述赋值语句即可。

09-10 03:54
查看更多