Использование long и массивов в C++

Question

Я работал над программой, которая преобразует числа в двоичные. Поскольку вы можете увидеть мою программу here, я написал так, чтобы она могла масштабироваться для больших чисел, а затем традиционный двоичный код, такой как 2 строки (16 бит) для чисел, больших 255. Однако для большего размера требуется длинный вместо int , но это, похоже, не играет хорошо, производя вывод, такой как this. Кто-нибудь может помочь мне изменить программу, чтобы использовать ее долго? Или потребовалось бы фундаментальное изменение кода вместо небольших изменений?

#include <iostream> 
#include <math.h> 
using namespace std; 
int main(int argc, char **argv) 
{ 
    int j=0; 
    int c=8; 
    long a = 1; 
    int i=1; 
    cin >> a; 
    while (a >= (pow(2,c))) { 
     c = c+8; 
     i++; 
     } 
    long block[i*8]; 
    for (long tw;tw<(i*8);tw++) 
    { 
     block[tw] = 0; 
    } 
    j=((i*8)-1); 
    long b = 0; 
    while (j != -1) 
    { 
     if (b+(pow(2,j))<=a) 
     { 
      block[j]=1; 
      b=b+(pow(2,j)); 
     } 

     j--; 
    } 
    long q=0; 
    cout << endl; 
    int y=1; 
    long z = 0; 
    for (y;y<=i;y++) { 
     for (z;z<8;z++) { 
      cout << block[z+q]; 
     } 
     cout << endl; 
     z = 0; 
     q = q + (8*y); 
     } 
    } 

Answer 1

Вы делаете код намного сложнее, чем нужно. Это напечатает один 32-разрядное целое число в двоичной системе:

const unsigned int bit_count = sizeof(int) * 8 - 1; 

int a; 
std::cin >> a; 

for (unsigned int i = bit_count; i > 0; --i) 
{ 
    unsigned int t = (1 << i); 
    std::cout << (a & t ? "1" : "0"); 
} 
std::cout << (a & 1 ? "1" : "0"); 
std::cout << std::endl; 

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

Answer 2

Почему бы не просто так? Вы можете сохранить промежуточные бит в массиве или строку вместо использования cout.

int convert(long n) 
{ 
    long k=1; 
    while(k<n)//find the most significant bit 
    { 
     k*=2; 
    } 
    if(k>n)//fix the overshoot 
    { 
     k/=2; 
    } 

while(k>0) 
{ 
    if(int(n/k)%2==0) 
    { 
     cout<<0;//find the (next) most 
    } 
    else 
    { 
     cout<<1;//significant binary digit 
    } 
    k/=2;//go to the next column to the right and repeat 
} 
} 

Answer 3

Для более гибкого, вот еще один способ сделать это с помощью шаблонов. Шаблонные экземпляры с подписанными типами умышленно исключаются из-за проблем с расширением.

template <typename T> 
void print_binary(const T input, const short grouping = 4) 
{ 
    unsigned int bit_count = sizeof(T) * 8; 
    T nth_bit = 1 << (bit_count - 1); 

    for(int i = 0; i < bit_count; i++, nth_bit >>= 1) 
    { 
     cout << (input & nth_bit ? "1" : "0"); 
     if(i % grouping == grouping-1) // print binary in groups 
      cout << ' '; 
    } 

    cout << endl; 
} 

template <> 
void print_binary<signed>(const signed input, const short grouping); 
template <> 
void print_binary<signed short>(const signed short input, const short grouping); 
template <> 
void print_binary<signed long>(const signed long input, const short grouping); 
template <> 
void print_binary<signed char>(const signed char input, const short grouping);