Как перевести из десятичной в двоичную c

Перевод из десятичной в двоичную систему счисления C++

Вы делаете неправильно. Вы пытаетесь построить такое число, чтобы если его вывести как десятичное, получилось двоичное представление числа.

Это не правильно, так делать не надо, это лишь приведёт к проблемам. Нужно различать само число (переменную числового типа) и его представление в той или иной системе счисления (строку).

#include std::string to_binary_string(unsigned int n) < std::string buffer; // символы ответа в обратном порядке // выделим память заранее по максимуму buffer.reserve(std::numeric_limits::digits); do < buffer += char('0' + n % 2); // добавляем в конец n = n / 2; >while (n > 0); return std::string(buffer.crbegin(), buffer.crend()); // разворачиваем результат > 

Для случая, когда вам нужно обрабатывать и отрицательные числа, нужна небольшая модификация:

#include #include std::string to_binary_string(int n) < if (n == std::numeric_limits::min()) return "-1" + std::string(std::numeric_limits::digits, '0'); std::string buffer; buffer.reserve(std::numeric_limits::digits + 1); // +1 для минуса bool negative = (n < 0); if (negative) n = -n; do < buffer += char('0' + n % 2); n = n / 2; >while (n > 0); if (negative) buffer += '-'; return std::string(buffer.crbegin(), buffer.crend()); > 

Это решение естественно обобщается на произвольный тип:

#include #include #include template std::string to_binary_string(T n) < static_assert(std::is_integral::value, "Integer required."); if (std::numeric_limits::is_signed && n == std::numeric_limits::min()) // (*) < // переполнение в знаковом типе - UB, избегаем его return "-1" + std::string(std::numeric_limits::digits, '0'); > std::string buffer; buffer.reserve(std::numeric_limits::digits + 1); // +1 для возможного минуса bool negative = (n < 0); if (negative) n = -n; // это можно делать вследствие проверки (*) do < buffer += char('0' + n % 2); n = n / 2; >while (n > 0); if (negative) buffer += '-'; return std::string(buffer.crbegin(), buffer.crend()); > 

(Код частично украден из этого ответа.)

Величина std::numeric_limits::digits представляет количество бит в знаковом целочисленном типе, участвующих в представлении значения (без учёта знакового бита и битов заполнения (padding bits)), соответственно даёт количество двоичных цифр в самой длинной строке (за исключиением отрицательного минимума).

Отслеживать
ответ дан 25 июн 2015 в 20:05
207k 28 28 золотых знаков 293 293 серебряных знака 526 526 бронзовых знаков
да вы правы, есть очень много вариантов. человек выбрал это.
25 июн 2015 в 20:10

@SaidolimDjuraev: Мне кажется, что число, которое будучи выведенным как десятичное будет выглядеть, как двоичное представление другого числа, имеет достаточно слабую семантику. Кроме того, с строкой можно представить как угодно большие числа, а вот число 255 в двоичном виде будет 11111111 и не поместится в один байт в предлагаемой схеме.

25 июн 2015 в 20:21
согласен вы правы
25 июн 2015 в 20:29
@wololo: спасибо, с вашими правками вышло изящнее
7 мая 2021 в 11:06

1. Вы отрезаете последнее значение при num=num/2; Это должно быть в конце цикла.
2. Значения нужно выводить в обратном порядке.

Вот изменил код. Проверьте.

тут d это разряд. Потому что нужно обратно все печатать.

#include using namespace std; int main() < int num=0, t=0, d=1; cout"; cin>>num; while(num) < t +=(num%2)*d; //coutcout
Отслеживать
ответ дан 25 июн 2015 в 13:32
8,331 4 4 золотых знака 26 26 серебряных знаков 48 48 бронзовых знаков
Вы имели в виду это? while(num) < t=num%2; cout<int a; int tmp = 1; std::cin >> a; if (a < 0) < a *= -1; std::cout if (a == 0) std::cout 1) < tmp = tmp >> 1; std::cout > 

Отслеживать
ответ дан 6 мая 2021 в 10:49
11 2 2 бронзовых знака
6 мая 2021 в 10:51

Вот 2 функции, которые я когда-то давно писал.

Первая функция переводит из 10-ой системы счисления целые числа в любую другую систему счисления от 2 до 36.

std::string TransferDecimalToAny(long long int number, const unsigned int &base) < const char *DIGITS = "0123456789abcdefghijklmnopqrstuvwxyz"; bool FlagInverse = false; std::string reversString, stringInBase; if (base < 2 || base >36) < std::cout if (number < 0) < FlagInverse = true; number *= -1; >stringInBase += DIGITS[number % base]; number = number / base; while (number) < stringInBase += DIGITS[number % base]; number = number / base; >if (FlagInverse == true) reversString = "-"; for (int i = stringInBase.length() - 1; i >= 0; i--) reversString += stringInBase[i]; return reversString; > 

А вторая функция также переводит из 10-ой системы счисления в любую другую систему счисления от 2 до 36, но только уже дробные числа причем с заданной точностью accuracy.

std::string TransferDecimalToAny(long double number, const unsigned int &base, const int &accuracy) < const char *DIGITS = "0123456789abcdefghijklmnopqrstuvwxyz"; int iter = 0, tmp = 0; bool FlagInverse = false; if (number < 0) < FlagInverse = true; number *= -1; >long long int integer; long double integer_tmp, fractional; std::string reversString, stringInBase; if (base < 2 || base >36) < std::cout fractional = modf(number, &integer_tmp); integer = static_cast(integer_tmp); stringInBase += DIGITS[integer % base]; integer = integer / base; while (integer) < stringInBase += DIGITS[integer % base]; integer = integer / base; >if (FlagInverse == true) reversString = "-"; for (int i = stringInBase.length() - 1; i >= 0; i--) reversString += stringInBase[i]; reversString += '.'; while (iter < accuracy) < fractional *= base; fractional = modf(fractional, &integer_tmp); tmp = static_cast(integer_tmp); reversString += DIGITS[tmp]; iter++; > return reversString; > 

А вызывать их соответственно следующим образом:

long long int number1 = -54605429; long double number2 = -6546747.63768658; std::cout > base; std::cout  

int dec2bin(int num) < int bin = 0, k = 1; while (num) < bin += (num % 2) * k; k *= 10; num /= 2; >return bin; >

 for(;b>0;b/=2)

while (chislo != 0) < ost=chislo%2; chislo=chislo/2; r*=10+ost; i++; >

#include int main() < int a, n, b, c; scanf("%d", &a); n=a; while (n!=0) < c=n%2; n=n/2; b=b*10+c; >printf("\nbin = %d\n", b); >

#include #include #include char * decToBin(int x) < char *t = (char *)malloc(100); int i = 0; do < t[i++] = x % 2 + '0'; x = x / 2; >while (x != 0); t[i] = '\0'; // инвертируем t int k = strlen(t) - 2; int m = k / 2; for (int i = 0; i return t; > int main()

#include #include #include char * decToBin(int x) < char *t = (char *)malloc(100); int i = 0; do < t[i++] = x % 2 + '0'; x = x / 2; >while (x != 0); t[i] = '\0'; // инвертируем t int k = strlen(t) - 2; int m = k / 2; for (int i = 0; i return t; > int main()

for(i; i!=0; i--)

for(i; i!=0; i--)

#include int main() < int a, n, b=1, i=0, c; scanf("%d", &a); n=a; while (n!=0) < c=n%2; n=n/2; if(c==1) b=b*10+1; else b=b*10+0; i++; >printf("\nbin = %d\n", b); >

// переворачиваем Б b/=10; // отбрасываем последний разряд (он всегда равен 1) и заносим его в Д //еще можно предыдущий цикл сдеать while (n!=1) и тогда этот шаг можно будет пропустить int d=1; //перевернутая Б for(i--; i!=0; --i) //идем по каждому разряду Б (пока они не закончатся) < d=d*10+b%10 //переписываем в конец Д последнюю цифру Б b/=10; //удаляем последнюю цифру из Б >

#include int main() < //. getch(); return 0; >