Как ограничить двоичный файл, отображаемый в моем десятичном в двоичный преобразователь?

Question

У меня пока есть этот код:

for ( int i = 16; i >=0; i--){
   int k = n >> i;
   if (k & 1)
     printf("1");
   else
     printf("0");
}

Я чрезвычайно новичок в C и работаю над десятичным в двоичное преобразование для класса.Пока это то, что я обнаружил, что работает в моих параметрах.Единственная проблема в том, что мне нужен этот код, чтобы ТОЛЬКО выводить двоичный файл в MSD, который был ему предоставлен.

Как если бы у меня был десятичный 15, он должен отображать 1111 в двоичном виде, а если у меня десятичный 16, он должен отображать только следующий набор из 4 выше, поэтому 00010000.

По состоянию наПрямо сейчас я могу установить сумму на то, что я хочу, как в i = 16, но это покажет всего 15 пробелов.где, как будто я вставил небольшое десятичное число, я не хочу, чтобы моя программа показывала все лишние ненужные 0.

Так есть ли способ ограничить двоичный вывод, чтобы он соответствовал, скажем, самому значительному пространству, необходимому дляточно отобразить его конверсию?

Answer 1

Чтобы отсортировать это в группы по 4, вам нужно поработать над клевом.Функция, которая печатает полубайт (значение от 0 до 15 декабря), может выглядеть следующим образом:

void print_bin_nibble (uint8_t ls_nibble)
{
  for(size_t i=0; i<4; i++)
  {
    uint8_t bitmask = 1u << (4-1-i);
    printf("%c", (ls_nibble & bitmask) ? '1' : '0');
  }
  printf(" ");
}

Теперь, если вы хотите распечатать данные по кусочкам, пропуская ведущие нули для полубайтов, равных 0000 bin,вам нужно отслеживать, следует ли пропустить печать с логическим флагом.Логика будет такой:

if(nibble==0 && remove_zeroes)
{
  ; // do nothing
}
else
{
  remove_zeroes = false;
  print_bin_nibble(nibble);
}

, которая может быть переписана как (законы де Моргана):

if(nibble != 0 || !remove_zeroes)
{
  remove_zeroes = false;
  print_bin_nibble(nibble);
}

Дальнейшее рассмотрение при печати числа - это постоянство ЦП.Существуют различные (плохие) способы, которыми мы можем перебирать целочисленный байт за байтом, например, используя арифметику указателей или объединения.Но тогда результат будет зависеть от порядка байтов и будет выглядеть странно на машинах с прямым порядком байтов.Используя сдвиги битов, мы полностью устраняем эту проблему переносимости, поскольку они не зависят от порядка байтов.

Например, для 32-битного целого числа u32 мы можем замаскировать отдельные байты следующим образом:

(u32 >> (24-n*8)) & 0xFF

где n - номер байта от 0 до 3. В итоге мы сдвигаем 24 бита для n = 0, 16 бит для n = 1, 8 бит для n = 2 и 0 бит для n = 3.

Полный пример:

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

void print_bin_nibble (uint8_t ls_nibble)
{
  for(size_t i=0; i<4; i++)
  {
    uint8_t bitmask = 1u << (4-1-i);
    printf("%c", (ls_nibble & bitmask) ? '1' : '0');
  }
  printf(" ");
}

void print_bin32 (uint32_t u32)
{
  bool remove_zeroes = true;

  for(size_t i=0; i<sizeof(u32); i++)
  {
    uint8_t byte = (u32 >> (24-i*8)) & 0xFF;
    uint8_t nibble;

    nibble = (uint32_t)byte >> 4;
    if(nibble != 0 || !remove_zeroes)
    {
      remove_zeroes = false;
      print_bin_nibble(nibble);
    }

    nibble = byte & 0xF;
    if(nibble != 0 || !remove_zeroes)
    {
      print_bin_nibble(nibble);
    }
  }
  printf("\n");
}

int main (void)
{
  print_bin32(16);
  print_bin32(0xDEADBEEF);
  print_bin32(0xABBA);
}

Вывод:

0001 0000
1101 1110 1010 1101 1011 1110 1110 1111
1010 1011 1011 1010

Answer 2

Один из способов сделать это - использовать переменную flag, чтобы проверить, есть ли у нас ненулевой msb, и начать печатать 0 только после того, как мы встретим ненулевой msb, например,

int flag
for ( int i = 16; i >=0; i--)
{
int k = n >> i;

if (k & 1){
  printf("1");
  flag = 1;
}else{
  if(flag)
    printf("0");
}