使用按位运算符重建整数

如何解决使用按位运算符重建整数

我正在做一个分配，其中必须生成随机数量的可变大小，将每个字节存储在数组中，然后通过串联字节来重建该数字。

例如，如果我们的数字是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[],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[],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[],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

但是，当我在sum函数中执行相同的操作时：

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) );

我只是无法为自己的生活弄清楚它是什么！ 谢谢大家！

解决方法

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

如果您仔细观察pd.melt(df,var_name"year",value_name="values").reindex(index) year values 2015 1 NaN NaN 2 NaN NaN 3 NaN NaN 4 NaN NaN 5 NaN NaN 2020 1 NaN NaN 2 NaN NaN 3 NaN NaN 4 NaN NaN 5 NaN NaN 2025 1 NaN NaN 2 NaN NaN 3 NaN NaN 4 NaN NaN 5 NaN NaN 2030 1 NaN NaN 2 NaN NaN 3 NaN NaN 4 NaN NaN 5 NaN NaN 2035 1 NaN NaN 2 NaN NaN 3 NaN NaN 4 NaN NaN 5 NaN NaN 2040 1 NaN NaN 2 NaN NaN 3 NaN NaN 4 NaN NaN 5 NaN NaN 2045 1 NaN NaN 2 NaN NaN 3 NaN NaN 4 NaN NaN 5 NaN NaN 2050 1 NaN NaN 2 NaN NaN 3 NaN NaN 4 NaN NaN 5 NaN NaN ，您会发现(*mem << 24)是字符。因此是您的第一次转化中的另一种类型。

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

,

这可能不是最好的方法，但这正是我为自己的任务和简单起见而工作的最终结果：

我必须先将低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;
}

然后我进一步扩展它以使用双字（长长）数据类型：

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;
}

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

,

我会做这样的事情以避免对有符号整数进行运算

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);
}