使用按位运算符重构整数

Question

我正在处理一项作业，其中我必须生成可变大小的随机数，将每个单独的字节存储在数组中，然后通过连接字节重建该数字。

例如，如果我们的数字是 16 位二进制 1100001111110000，我们将有一个函数将这个数字放入一个数组中。我们的数组将包含 2 个索引：110000111 和 1110000。然后我们有另一个知道大小的函数，并结合两个索引来创建原始数字。

然后我们必须计算数组中所有 16 位整数的总和。这是我加载数据并将其求和的内容 mem[] 是一个使用大小为 size:

的 malloc 分配的块

void loadhalfwdata(char mem[], int size) {
    int i, result;
    for (i = 0; i < (size >> 1); i++) {
        result = (rand() & 0x7fff);
        *mem = (char)(result >> 8);
        *(mem + 1) = (char)(result & 0xff);
        mem += 2;
    }
}

int sumhalfwdata(char mem[], int size) {
    int i, sum, result;
    sum = 0;
    for(i = 0; i < (size >> 1); i++) {
        result = *mem << 8;
        result |= (*(mem + 1) & 0xff);
        sum += result;
        mem+= 2;
    }

    return sum;
}

这行得通，一切都很棒！现在，当我尝试将其扩展为 32 位整数时，事情似乎不太顺利。

void loadworddata(char mem[], int size) {
    int i, result;
    for(i = 0; i < (size >> 2); i++) {
        result = (rand() & 0x7fffffff);
        *mem = (char)(result >> 24);
        *(mem + 1) = (char)(result >> 16 & 0xff);
        *(mem + 2) = (char)(result >> 8 & 0xff);
        *(mem + 3) = (char)(result & 0xff);
        mem += 4;
    }
}

int sumworddata(char mem[], int size) {
    int i, sum, result;
    sum = 0;
    for(i = 0; i < (size >> 2); i++) {
        result = (*mem << 24) | ( *(mem + 1) << 16 ) | ( *(mem + 2) << 8 ) | ( *(mem + 3) );
        sum += result;
        mem += 4;
    }

    return sum;
}

我在网上找到了一个函数来帮助我将这些整数转换为二进制，当我加载数字时，这是输出：

LOADING WORD:
Word: 1102520059
As Binary: 01000001101101110001111011111011
First 8 bits: 01000001

Second 8 bits: 10110111

Third 8 bits: 00011110

Fourth 8 bits: 11111011

然而，当我在求和函数中做同样的事情时：

SUMMING WORD:
Word: -14
As Binary: 11111111111111111111111111110010
First 8 bits: 00101110

Second 8 bits: 10110001

Third 8 bits: 01000001

Fourth 8 bits: 11110010

我假设它与以下语句有关： result = (*mem << 24) | ( *(mem + 1) << 16 ) | ( *(mem + 2) << 8 ) | ( *(mem + 3) );

我一辈子都弄不明白那是什么！谢谢大家！

Answer 1

我会做这样的事情来避免对有符号整数进行操作

void code(unsigned char *buff, int x)
{
    union
    {
        unsigned int u;
        int i;
    }ui = {.i = x};
    for(size_t index = 0; index < sizeof(x); index++)
    {
        *buff++ = ui.u;
        ui.u >>= CHAR_BIT;
    }
}

unsigned int decode(unsigned char *buff)
{
    union
    {
        unsigned int u;
        int i;
    }ui = {.u = 0};
    
    for(size_t index = 0; index < sizeof(ui); index++)
    {
        ui.u |= (unsigned int)*buff++ << index * CHAR_BIT;
    }
    return ui.i;
}


int main(void)
{
    int x = -45678 ,y;
    unsigned char buff[sizeof(x)];

    code(buff, x);
    y = decode(buff);

    printf("%d\n", y);
}

Answer 2

我会说你对这条线的猜测是正确的。

如果仔细查看 (*mem << 24)，您会注意到 *mem 是一个 char。所以在你的第一次转换中使用另一种类型。

我认为this question可能会启发这种情况。

Answer 3

这可能不是最好的方法，但在我的任务需要的背景下，为了简单起见，它最终对我有用：

在移动它们之前，我必须抓住低 8 位（通过掩码），如下所示：

int sumworddata(char mem[], int size) {
    int i, sum, result;
    sum = 0;
    for(i = 0; i < (size >> 2); i++) {

        // COMBINE EACH SET OF 4 BITS
        result = (*mem & 0xff) << 24;
        result |= (*(mem + 1) & 0xff) << 16;
        result |= (*(mem + 2) & 0xff) << 8;
        result |= (*(mem + 3) & 0xff);

        sum += result;
        mem += 4;
    }

    return sum;
}

然后我进一步扩展它以使用 double-word（long long）数据类型：

long long sumdoublewdata(char mem[], int size) {
    int i;
    long long sum = 0;
    long long result;
    for(i = 0; i < (size >> 3); i++) {

        result = (long long)(*mem & 0xff) << 56;
        result |= (long long)(*(mem + 1) & 0xff) << 48;
        result |= (long long)(*(mem + 2) & 0xff) << 40;
        result |= (long long)(*(mem + 3) & 0xff) << 32;
        result |= (long long)(*(mem + 4) & 0xff) << 24;
        result |= (long long)(*(mem + 5) & 0xff) << 16;
        result |= (long long)(*(mem + 6) & 0xff) << 8;
        result |= (long long)(*(mem + 7) & 0xff);

        sum += result;

        mem += 8;
    }

    return sum;
}

非常感谢这里和评论中的所有人的帮助！

使用按位运算符重构整数

Reconstructing an integer using bitwise operators

c

bit-manipulation

bitwise-operators

bit-shift

bitwise-or