Преобразование десятичных чисел в 32-битные двоичные

Question

Привет, я даю задание для программирования в классе C, и вопрос, который я застрял, - это. «Предлагает пользователю ввести допустимое целое число от 0 до 2147483647 включительно, а затем отображает преобразованный значение в виде 32-разрядного двоичного числа с 1 пространство, отделяющее каждый 8-бит в двоичное значение. Если недействительный номер (то есть < 0 или> 2147483647) « он хочет, чтобы я вывел двоичный файл в 32-битном формате, таком как 00000000 00000000 00000000 00011111 = 31 со всеми 0 и интервалами между каждым набором из 8, и я застрял.

printf("enter a valid integer between 0 and 2147483647\n"); 
       scanf("%d",&decimal); 
       fflush(stdin); 
       if (decimal>0||decimal<2147483647) 
        {while (decimal!=0) 
        { 
          remainder = decimal%2; 
          binary=(remainder*place)+binary; 
          decimal=decimal/2; 
          place=place*10;} 
        printf("%d",binary);} 

этот видa работает до тех пор, пока вход не будет превышать 1000, после чего его перепутают. неужели и почему.

Answer 1

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

Вы можете изучить бит с использованием побитовых операторов . Вы можете создать двоичный номер 1000 0000 0000 0000 с номера 1 по левый сдвиг число 31 место: 1<<31. Затем вы можете проверить, имеет ли ваш номер 32-й бит с побитовым и: (1<<31) & decimal. Если результат равен нулю, этот бит не был установлен. Если результат отличен от нуля, бит был установлен.

Предполагая одноразрядных значение (обычно это называется маска) хранится в unsigned int, вы можете проверить 31-й бит правой кнопкой сдвигая его однажды:

unsigned int mask = 1 << 31; // mask for 32nd bit 
mask = mask >> 1; // move mask to 31st bit 
if (mask & decimal != 0) { 
    // 31st bit is set 
} 
else { 
    // not set 
} 

спользование unsigned int является очень важно. Если вы используете обычный (подписанный) int, то оператор >> имеет другое поведение. Для чисел без знака при смещении вправо левая сторона дополняется нулями. Для подписанных чисел левая сторона вместо этого дополняется любым значением (0 или 1) в самом старшем бите. Итак, если у вас есть , подписанное двоичное значение 1000 0000 0000 0000, и вы переместите его вправо 1 (signed_mask >> 1), то в итоге вы получите 1100 0000 0000 0000, а не 0100 0000 0000 0000.

Вот рабочий пример:

#include <stdio.h> 

int main(int argc, char *argv[]) { 
    int i, j, decimal; 
    printf("enter a valid integer between 0 and 2147483647\n"); 
    scanf("%d",&decimal); 
    fflush(stdin); 
    // all signed integers are <= 2147483647, so just check if it's positive 
    if (decimal>0) { 
     // create a "mask" to look at the 32nd bit 
     // note that we use an unsigned mask! 
     // this is important because we don't want 
     // sign-extending when we shift to the next bit. 
     unsigned int mask = 1<<31; 
     for (i=0; i<8; i++) { 
      for (j=0; j<4; j++) { 
       // check current bit, and print 
       char c = (decimal & mask) == 0 ? '0' : '1'; 
       putchar(c); 
       // move down one bit 
       mask >>= 1; 
      } 
      // print a space very 4 bits 
      putchar(' '); 
     } 
     putchar('\n'); 
    } 
    return 0; 
} 

Примечание условие decimal>0||decimal<2147483647 в вашем коде всегда верно. Я думаю, вы хотели использовать &&, а не ||. Однако 2147483647 является максимальным значением для подписанного 32-битного целого числа (2 -1), поэтому на самом деле не имеет смысла проверять верхнюю границу.

Answer 2

Проблема в том, что binary не достаточно большой, чтобы удерживать 32 0 и 1. Вы можете заметить, что максимальное допустимое число составляет около десяти десятичных цифр. Это все int может хранить на большинстве систем.

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