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

Question

Я работал над программой, которая конвертирует числа в двоичные числа.Как вы можете видеть мою программу здесь , я написал так, что она может масштабироваться для больших чисел, чем традиционный двоичный код, такой как 2 строки (16 бит) для чисел, больших 255. Однакобольше требует long вместо 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

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

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

Answer 3

Почему бы не что-то простое, как это? Вы можете хранить промежуточные биты в массиве или строке вместо использования 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
 }
}