使用 C 中的查找表反转/镜像 64 位

Question

我正在尝试实现一个功能：

• 创建一个包含 256 个反转整数的查找表（即table[1] 将包含 10000000₂）。
• 接收一个 8 字节的值，该值被拆分为 1 字节的块。
• 查找每个 8 位块以获取其反转位，并且
• 连接位并将连接后的值分配给一个 8 字节的变量，该变量将作为函数的返回值。

我的代码：

#include <stddef.h>


typedef size_t bitsarr_ty;  /* Assuming 64-bit system - size of 8 bytes */

typedef enum
{
    NOT_INITIALIZED,
    INITIALIZED
} mirrored_lut_status_ty;

static int mirrored_bits_lut[256] = {0};



bitsarr_ty BitArrayMirror(bitsarr_ty bitarr);

mirrored_lut_status_ty mirrored_lut_status = NOT_INITIALIZED;

/******************************* InitMirroredLUT **********************/

void InitMirroredLUT()
{
    size_t integer_value = 0;

    for (integer_value = 0; integer_value < 256; ++integer_value)
    {
        mirrored_bits_lut[integer_value] = BitArrayMirror(integer_value);
    }
}

/******************************* BitArrayMirror **********************/

bitsarr_ty BitArrayMirror(bitsarr_ty bitarr)
{
    size_t curr_bit_index = 0;  
    bitsarr_ty mirrored_bitarr = 0; 

    for (curr_bit_index = 0; curr_bit_index < 64; ++curr_bit_index) 
    { 
        if((bitarr & (1UL << curr_bit_index)))
        {
            mirrored_bitarr |= 1UL << ((64 - 1) - curr_bit_index); 
        }  
    } 

    return(mirrored_bitarr); 
}

bitsarr_ty BitArrayMirrorLUT(bitsarr_ty bitarr)
{
    bitsarr_ty mirrored_bitarr = 0;

    if (NOT_INITIALIZED == mirrored_lut_status)
    {
        InitMirroredLUT();
        mirrored_lut_status = INITIALIZED;
    }

    mirrored_bitarr = mirrored_bits_lut[bitarr & 0xff] << 56 |
        mirrored_bits_lut[(bitarr >> 8) & 0xff] << 48 |         
        mirrored_bits_lut[(bitarr >> 16) & 0xff] << 40 |
        mirrored_bits_lut[(bitarr >> 24) & 0xff] << 32 |         
        mirrored_bits_lut[(bitarr >> 32) & 0xff] << 24 |
        mirrored_bits_lut[(bitarr >> 40) & 0xff] << 16 |
        mirrored_bits_lut[(bitarr >> 48) & 0xff] << 8 |            
        mirrored_bits_lut[(bitarr >> 56) & 0xff];

    return (mirrored_bitarr);
}

它编译并运行时输出错误。

对于以下输入：

0000000000000000000000000000010000000000000000010000000000000000

我得到以下输出：

0000000000000000000000000000000000000000000000000000000000000000

还有以下错误：

In function ‘BitArrayMirrorLUT’:
source/bit_array.c:321:53: warning: left shift count >= width of type [-Wshift-count-overflow]
  321 |  mirrored_bitarr = mirrored_bits_lut[bitarr & 0xff] << 56 |
      |                                                     ^~
source/bit_array.c:322:49: warning: left shift count >= width of type [-Wshift-count-overflow]
  322 |         mirrored_bits_lut[(bitarr >> 8) & 0xff] << 48 |
      |                                                 ^~
source/bit_array.c:323:50: warning: left shift count >= width of type [-Wshift-count-overflow]
   |         mirrored_bits_lut[(bitarr >> 16) & 0xff] << 40 |
      |                                                  ^~
source/bit_array.c:324:50: warning: left shift count >= width of type [-Wshift-count-overflow]
   |         mirrored_bits_lut[(bitarr >> 24) & 0xff] << 32 |

我的错误是什么？

Answer 1

因为在计算 mirrored_bits_lut 时，您将 8 位数字反转为 64 位数字。转换为 32bit int 时忽略所有重要位