-1

我正忙于一个项目，需要在 C 中实现以下功能

void logic_circuit(int inputs[4],int outputs[2])

需要创建一个计数器，因为所有 4 位组合都需要插入到这个函数中......

void logic_circuit(int inputs[4],int outputs[2])
{
      //some calculations
      outputs[0] = ...
      outputs[1] = ...
}

//allocate memory
int inputs[4];
int outputs[2];

for(0000 to 1111)
{
     logic_circuit(0000,outputs);
}

我一直在密集搜索网络，但不幸的是我找不到任何有用的东西。有人知道如何解决这个问题吗？

4

5 回答 5

1

除了四个嵌套循环，您还可以inputs从单个循环计数器填充数组，

for(mask = 0; mask < 0x10; ++mask) {
    for(index = 0; index < 4; ++index) {
        inputs[index] = (mask >> index) & 1;
    }
    logic_circuit(inputs, output);
}

这可以更好地扩展到更大的inputs阵列。

于 2012-09-23T19:37:41.847 回答
0 
for(int i=0; i < bitSize; i++){
    if(outputs[i]==1){        
        outputs[i] = 0;
        continue;
    }
    if(outputs[i]==0){ 
        outputs[i] = 1;
        logic_circuit(inputs, outputs);
        i = 0;
    }
}

如果你不想使用位数组，你可以使用这样的位掩码

int mask = 1;
outputs[i] &= mask << i;

这将适用于任何大小的位数组（或者如果您想使用屏蔽方法，您选择用于 int 的任何宽度）

于 2012-09-23T20:49:27.643 回答
0

对于这个简单的例子，四个嵌套for循环应该可以工作：

for (inputs[0] = 0; inputs[0] < 2; ++inputs[0]) {
  for (inputs[1] = 0; inputs[1] < 2; ++inputs[1]) {  
    for (inputs[2] = 0; inputs[2] < 2; ++inputs[2]) {
      for (inputs[3] = 0; inputs[3] < 2; ++inputs[3]) {
        logic_circuit(inputs, outputs);
      }
    }
  }
}

对于较大的输入，这变得非常烦人。递归方法可以更好地扩展：

void enumerate_bits(int* bits, int n) {
  int bit;
  if (n == 0) {
    logic_circuit(bits, outputs);
  } else {
    for (bit = 0; bit < 2; ++bit) {
      bits[n-1] = bit;
      foo(bits, n-1);
    }
  }
}

enumerate_bits(inputs, 4);
于 2012-09-23T19:31:30.010 回答
0

0您可以简单地从to计数15并将位提取到数组中：

for (int i=0; i <= 15; i++) {
    inputs[0] = i & 0x1;
    inputs[1] = i & 0x2;
    inputs[2] = i & 0x4;
    inputs[3] = i & 0x8;
    logic_circuit(inputs, outputs);
}

请注意，这不会将0s 和1s 放入数组中，而是将0s 或非s 放入数组中0（例如，15它将放入 s 中[1, 2, 4, 8]）。

于 2012-09-23T19:34:44.647 回答
0

使用位掩码很好，但使用数组很容易，并且对大小没有限制：

// produce next combination of inputs, returning false if it has cycled back to all off
bool increment(bool* ary, int len)
{
    for( int i = 0; i < len; i++ )
        if( (ary[i] = !ary[i]) )
            return true;

    return false;
}

void enumerate(void)
{
    bool inputs[4];
    memset(inputs, 0, sizeof inputs);

    // loop over all combinations of inputs
    do
    {
        logic_circuit(inputs, outputs);
    } while (increment(inputs, 4));
}
于 2012-09-23T19:55:27.107 回答