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

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

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

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

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