двоичный счетчик в C

Question

я занят проектом, в котором следующая функция должна быть реализована в 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); 
} 

Я был поиск в Интернете интенсивно, но, к сожалению, я was'nt смог найти что-нибудь usefull.Does нибудь есть идеи о том, как решить эту проблему?

Answer 1

Вместо четырех вложенных циклов, вы можете также заполнить inputs массив из одного счетчика цикла,

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

, что весы лучше больших inputs массивов.

Answer 2

Для этого простого случая, четыре вложенных 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); 

Answer 3

Вы можете просто считать от 0 к 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); 
} 

Заметим, что это не ставит 0 с и 1 сек в массив, но, скорее, 0 s или не 0 s (например, для 15 он будет помещен в [1, 2, 4, 8]).

Answer 4

Использование битовых масок прекрасно, но это достаточно легко использовать массив, и нет никаких ограничений на размер:

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

Answer 5

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; 

это будет работать с массивом битых любого размера (или то, что когда-либо шириной вы решили использовать для междунаров если вы хотите использовать метод маскирования)