Хранение отдельных битов в памяти

Question

Поэтому я хочу хранить в памяти случайные биты длиной от 1 до 8 (байт). Я знаю, что компьютер недостаточно эффективен для хранения отдельных битов в памяти, и что мы должны хранить как минимум данные BYTE на большинстве современных машин. Я провел некоторые исследования по этому вопросу, но не нашел ни одного полезного материала. Мне нужно найти способ сохранить эти биты так, чтобы, например, при чтении битов обратно из памяти 0 не оценивалось как 00, 0000 или 00000000. Для дальнейшего объяснения, например, 010 НЕ должно читаться обратно или оценивается в этом отношении как 00000010. Числа должны быть уникальными в зависимости от значения, а также их количества элементов.

Еще несколько примеров;

1 ≠ 00000001

10 ≠ 00000010

0010 ≠ 00000010

10001 ≠ 00010001

И так далее ...

Еще одна вещь, на которую я хочу обратить внимание, это то, что бит Размер всегда между 1 и 8 (включительно) и не является фиксированным числом. Я использую C для этой проблемы.

Answer 1

Итак, вы хотите хранить биты в памяти и читать их обратно, не зная, сколько они стоят. Это невозможно. (Это невозможно и с байтами)

Представьте, если бы вы могли это сделать. Затем мы можем сжать файл, например, сказав, что «0» сжимает до «0», а «1» сжимает до «00». После этого «сжатия» (которое на самом деле увеличило бы размер файла) у нас есть файл только с 0. Затем мы сжимаем файл только с 0, записывая, сколько существует 0. Удивительно! Любой файл 2 ГБ сжимается до 4 байтов. Но мы знаем, что невозможно сжать каждый файл размером 2 ГБ в 4 байта. Так что с этой идеей что-то не так.

Вы можете прочитать несколько бит из памяти, но вам нужно знать, сколько вы читаете. Вы также можете сделать это, если вы не знаете, сколько бит вы читаете, но комбинации не "перекрываются". Таким образом, если «01» является допустимой комбинацией, то вы не можете иметь «010», потому что это будет перекрывать «01». Но вы могли бы иметь «001». Это называется код префикса и используется в кодировании Хаффмана , типе сжатия.

Конечно, вы также можете сохранить длину перед каждым числом. Таким образом, вы можете сохранить «0» как «0010», где «001» означает, сколько битов длинное число. С длиной 3-ди git вы можете иметь только до 7-битных чисел. Или 8-битные числа, если вычесть 1 из длины, и в этом случае вы не можете иметь нулевые биты. (поэтому «0» становится «0000», «101» становится «010101» и т. д. c)

Answer 2

Если вам просто нужно убедиться, что заданное двоичное число оценено правильно, у вас есть два варианта, которые я могу придумать. Вы можете хранить все количество битов каждого числа вместе с заданным числом, что не будет таким эффективным.

Но вы также можете хранить все двоичные числа как 8-битные, тогда при обработке каждый отдельный номер, пройти через все его цифры, чтобы найти его длину. Таким образом, вы просто сохраняете длину одного числа за раз.

Вот небольшой код, надеюсь, он понятен:

Uint8 rightNumber = 2; //Which is 10 in binary, or 00000010 
int rightLength = 2; //Since it is 2 bits long

Uint8 bn = mySuperbBinaryValueIWantToTest;
int i;
for(i = 7; i > 0; i--)
{
if((bn & (1 << i)) != 0)break;
}
int length = i + 1;
if(bn == rightNumber && length == rightLength) printf("Correct number");
else printf("Incorrect number");

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