Создайте двоичный шаблон, который сдвигает бит вправо

Вы можете использовать другую переменную (val_base в приведенном ниже коде) для хранения базового шаблона, к которому вы будете применять сдвиги текущего бита.

В приведенном ниже коде я использовал два вложенных цикла: один для перебора групп шаблонов (в каждой группе определенные биты слева равны 1), и один для сдвига текущего бита.

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

#include <stdio.h>
#include <stdint.h>


int main() {
    uint8_t val_base = 0;
    for (int iGroup = 0; iGroup < 8; ++iGroup) {  // iterate over the 8 groups of patterns
        for (int iShift = 0; iShift < (8-iGroup); ++iShift) { // iterate on the patterns in each group
            uint8_t val = (1 << iShift) + val_base;
            printf("%08B\n", val);
        }
        val_base |= (1 << (8 - iGroup - 1));    // for next iteration
    }
}

Выход:

00000001
00000010
00000100
00001000
00010000

...

11111010
11111100
11111101
11111110
11111111

Live demo

Примечание:
В рабочем коде самое эффективное, что вы можете сделать, — это, вероятно, создать жестко запрограммированную таблицу поиска со всеми шаблонами.
Вы все равно можете использовать приведенный выше код, чтобы легко создать эту таблицу поиска.

Я решил найти подвижный бит - установить бит, слева от которого есть неустановленный бит, и, если его нет, обработать крайние случаи (установить младший бит или перевернуть).

Вот реализация и тест:

char bitpattern_increment(char bits) {
char retval_new_pattern = 0;
int movable_bit_pos = 0;

if (bits == 0) {
    retval_new_pattern = 0x01;
    goto end;
}

for (; movable_bit_pos < 7; movable_bit_pos++) {
    if ((bits >> movable_bit_pos) & 0x01) {
        if (((bits >> (movable_bit_pos + 1)) & 0x01) == 0x00) {
            retval_new_pattern = bits & ~(0x01 << movable_bit_pos);
            retval_new_pattern |= (0x01 << (movable_bit_pos + 1));
            goto end;
        }
    }
}

if (bits == (char)0xFF) {
        retval_new_pattern = 0x00;
        goto end;
}

retval_new_pattern = bits | 0x01;

end: return retval_new_pattern;
}

Протестировал это следующим образом (начиная с 0xFF, чтобы легко проверять крайние случаи):

char bitpattern = 0xFF;
for (int i = 0; i < 40; i++) {
    bitpattern = bitpattern_increment(bitpattern);
    std::bitset<8> bitpattern_set(bitpattern);
    std::cout << bitpattern_set << std::endl;
}

Тестовый вывод:

00000000
00000001
00000010
00000100
00001000
00010000
00100000
01000000
10000000
10000001
10000010
10000100
10001000
10010000
10100000
11000000
11000001
11000010
11000100
11001000
11010000
11100000
11100001
11100010
11100100
11101000
11110000
11110001
11110010
11110100
11111000
11111001
11111010
11111100
11111101
11111110
11111111
00000000
00000001
00000010

Я предложу другой зацикленный ответ, основанный на способе перемещения растровых спрайтов старого стиля. Я думал, что это было довольно здорово, пока не увидел невероятный ответ Эрика. Таблица поиска IRL самая быстрая.

#include <stdio.h>

void shiftbits()
{
   int bits, k;
   k = bits = 0;
   printf("%2i : %08B \n", ++k, bits);
   for (int i = 8; i; i--)
   {
      int mask = 3;
      bits |= 1;
      printf("%2i : %08B \n", ++k, bits);
      for (int j = i-1 ; j; j--)
      {
          bits ^= mask;
          mask = mask + mask;
          printf("%2i : %08B \n", ++k, bits);
      }
   }
}

int main()
{
  shiftbits();
  return 0;
}

Его неэлегантность заключается в том, что printf встречается один раз в каждом из вложенных циклов.

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

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

Следующее кажется более прямым выражением желаемой цели. Вкусы различаются.

#include <stdio.h>
#include <stdint.h>

int main( void ) {
    uint8_t pwr = 0x80, val = 0, trv = 0;

    do {
        do {
            printf( "%08B\n", val | trv );
            trv = trv ? trv << 1 : 1; // shift left OR seed first '1'
        } while( trv < pwr ); // until shifted maximally
        val |= trv, trv = 0; // burn it in and reset to zero
    } while( ( pwr >>= 1 ) != 0 ); // shifting left boundary to the right
    printf( "%08B\n", val ); // spill the final version

    return 0;
}

Это можно увидеть бегущим здесь