在一个整数中找到另一个整数的 MSB 位置左侧的 N 个连续零位

问题是：给定一个整数val1然后，给定第二个整数，找到最高位组（最高有效位）的位置val2找到第一个整数生成的位置左侧的未设置位的连续区域。width指定minimum必须在连续中找到的未设置位的数量（即width里面没有 0）。

这是我的解决方案的 C 代码：

#include <limits.h> /* for CHAR_BIT - number of bits in a char */

typedef unsigned int t;
unsigned const t_bits = sizeof(t) * CHAR_BIT;

_Bool test_fit_within_left_of_msb(  unsigned width,
                                    t val1, /* integer to find MSB of */
                                    t val2, /* integer to find width zero bits in */
                                    unsigned* offset_result)
{
    unsigned offbit = 0; /* 0 starts at high bit */
    unsigned msb = 0;
    t mask;
    t b;

    while(val1 >>= 1) /* find MSB! */
        ++msb;

    while(offbit + width < t_bits - msb)
    {
        /* mask width bits starting at offbit */
        mask = (((t)1 << width) - 1) << (t_bits - width - offbit);
        b = val2 & mask;

        if (!b) /* result! no bits set, we can use this */
        {
            *offset_result = offbit;
            return true;
        }

        if (offbit++) /* this conditional bothers me! */
            b <<= offbit - 1;

        while(b <<= 1)
            offbit++; /* increment offbit past all bits set */
    }
    return false; /* no region of width zero bits found, bummer. */
}

除了更快地找到第一个整数的 MSB 之外，注释的零测试offbit看起来有点无关紧要，但有必要跳过类型的最高位t如果已设置。无条件左移b by offbit - 1位将导致无限循环，并且掩码永远不会超过 val2 的高位中的 1（否则，如果高位为零也没有问题）。

我也实现了类似的算法，但工作在第一个数字的 MSB 右侧，因此它们不需要这个看似额外的条件。

我怎样才能摆脱这个额外的条件，或者甚至，是否有更优化的解决方案？

编辑：一些背景不是严格要求的。偏移结果是从高位开始的位计数，而不是如预期的那样从低位开始。这将是更广泛算法的一部分，该算法扫描 2D 数组以查找零位的 2D 区域。 这里，为了测试，算法已被简化。val1表示第一个整数，该整数没有在 2D 数组的一行中找到所有位集。由此，2D 版本将向下扫描，这是什么val2代表。

以下是显示成功和失败的一些输出：

t_bits:32
     t_high: 10000000000000000000000000000000 ( 2147483648 )
---------

-----------------------------------
*** fit within left of msb test ***
-----------------------------------
      val1:  00000000000000000000000010000000 ( 128 )
      val2:  01000001000100000000100100001001 ( 1091569929 )
msb:   7
offbit:0 + width: 8 = 8
      mask:  11111111000000000000000000000000 ( 4278190080 )
      b:     01000001000000000000000000000000 ( 1090519040 )
offbit:8 + width: 8 = 16
      mask:  00000000111111110000000000000000 ( 16711680 )
      b:     00000000000100000000000000000000 ( 1048576 )
offbit:12 + width: 8 = 20
      mask:  00000000000011111111000000000000 ( 1044480 )
      b:     00000000000000000000000000000000 ( 0 )
offbit:12
iters:10


***** found room for width:8 at offset: 12 *****

-----------------------------------
*** fit within left of msb test ***
-----------------------------------
      val1:  00000000000000000000000001000000 ( 64 )
      val2:  00010000000000001000010001000001 ( 268469313 )
msb:   6
offbit:0 + width: 13 = 13
      mask:  11111111111110000000000000000000 ( 4294443008 )
      b:     00010000000000000000000000000000 ( 268435456 )
offbit:4 + width: 13 = 17
      mask:  00001111111111111000000000000000 ( 268402688 )
      b:     00000000000000001000000000000000 ( 32768 )
 ***** mask: 00001111111111111000000000000000 ( 268402688 )
offbit:17
iters:15


***** no room found for width:13 *****

（iters 是内部 while 循环的迭代次数，b 是结果val2 & mask)

This http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious有多种方法来计算无符号整数的以 2 为底的无符号整数对数（也是最高位集的位置）。

我认为这是你想要的一部分。我怀疑，如果我真的知道你想要什么，我可以建议一种更好的计算方法或达到相同目的的东西。