c - 在 C 中将位 vector 作为数组进行迭代的最佳方法

Question

以前，当我迭代位 vector 时，我会使用“0001”、“0010”、“0011”等字符串。我会使用 Java 将基数为 10 的整数解析为具有正确基数的字符串表示形式，但是我内存很快就耗尽了。

使用 C，我正在寻找一种迭代指定长度的位 vector 的方法。如果长度为 4，我将调用 int array[4] 并使用 for 循环将每个位置填充为 0 以开始。当我需要添加数字时，我的麻烦就开始了，从 [0,0,0,0] 到 [0,0,1,0]，依此类推，直到满足 [1,1,1,1] 的条件] 已满足。

我尝试了下面的代码。

int array[4];
for (i=0; i<4; i++)
{
  array[i] = 0;
}
for (i=0; i<4; i++)
{
  for(x=0; x<4; x++)
   {
     if (array[4-x] == 0 && (4-x) != 1)
      {
        array = array;
      }
     if (array[4-x] == 1)
      {
        array[4-x] == 0;
        array[4-x +1] ==1;
      }
   }
}

但这不正确。任何帮助，将不胜感激。

Answer 1

我会使用uint64_t来自<inttypes.h> (其中包括实际定义它们的 <stdint.h>)，最多 64 位。

如果我们对从 0 到 63 的位进行编号，其中 0 是最低有效位，则位 i 对应于数值 2ⁱ 。 (2⁰ = 1, 2¹ = 2, 2² = 4, 2³ = 8, 2 ⁴ = 16，依此类推。)

要测试特定位是否已设置(非零)或清除(零)，我们可以使用

static inline int  bit_is_set(const uint64_t  value, const int  bit)
{
    return !!(value & (((uint64_t)1) << bit));
}

static inline int  bit_is_clear(const uint64_t  value, const int  bit)
{
    return !(value & (((uint64_t)1) << bit));
}

如果该位已设置/清除，则以上返回 True (1)，否则返回 False (0)。

( ! 是 Not 运算符，逻辑逆。!! 是 Not-Not 运算符。如果 x 是算术表达式或数值，则 !!x 为 0(如果 x 为 0)，如果 x 非零，则为 1。这看起来很有趣，但请记住，它只是将零保持为零，并将非零转换为 1。非常有用。)

要更改单个位，我们可以使用

static inline uint64_t  set_bit(const uint64_t  value, const int  bit)
{
    return value | (((uint64_t)1) << bit);
}

static inline uint64_t  clear_bit(const uint64_t  value, const int  bit)
{
    return value & (~(((uint64_t)1) << bit));
}

static inline uint64_t  flip_bit(const uint64_t  value, const int  bit)
{
    return value ^ (((uint64_t)1) << bit);
}

在 C 中，参数是按值传递的，因此参数本身不变:函数返回指定位设置/清除/翻转(更改)的值。

你可以使用

    printf("value is now %" PRIu64 ".\n", value);

打印uint64_t value; 。

将命令行参数解析为 uint64_t s，我用类似的东西

#include <stdlib.h>
#include <inttypes.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
    uint64_t  a, b;
    char      dummy;

    if (argc != 3) {
        fprintf(stderr, "\n");
        fprintf(stderr, "Usage: %s [ -h | --help | help ]\n", argv[0]);
        fprintf(stderr, "       %s A B\n", argv[0]);
        fprintf(stderr, "\n");
        fprintf(stderr, "This program calculates the binary OR of A and B.\n");
        fprintf(stderr, "\n");
        return EXIT_FAILURE;
    }

    if (sscanf(argv[1], " %" SCNu64 " %c", &a, &dummy) != 1) {
        fprintf(stderr, "%s: Not a 64-bit unsigned integer.\n", argv[1]);
        return EXIT_FAILURE;
    }

    if (sscanf(argv[2], " %" SCNu64 " %c", &b, &dummy) != 1) {
        fprintf(stderr, "%s: Not a 64-bit unsigned integer.\n", argv[2]);
        return EXIT_FAILURE;
    }

    printf("A = %" PRIu64 "\n", a);
    printf("B = %" PRIu64 "\n", b);
    printf("A | B = %" PRIu64 "\n", a | b);

    return EXIT_SUCCESS;
}

请注意，scanf() 系列函数在溢出时不会出错。这意味着如果您提供 11111111111111111111111111111111 ，它将显示为其他内容，通常为 18446744073709551615 (=UINT64_MAX)。

有很多方法可以避免这种情况，最简单的是编写自己的解析器函数，但是如果您总是输出输入变量(就像上面的示例程序那样)，您可以假设用户会检查，而不必担心它典型案例。