С++ - десятичное преобразование в двоичное
Я написал программу "простой" (потребовался мне 30 минут), которая преобразует десятичное число в двоичный. Я УВЕРЕН, что там намного проще, так что вы можете мне показать?
Здесь код:
#include <iostream>
#include <stdlib.h>
using namespace std;
int a1, a2, remainder;
int tab = 0;
int maxtab = 0;
int table[0];
int main()
{
system("clear");
cout << "Enter a decimal number: ";
cin >> a1;
a2 = a1; //we need our number for later on so we save it in another variable
while (a1!=0) //dividing by two until we hit 0
{
remainder = a1%2; //getting a remainder - decimal number(1 or 0)
a1 = a1/2; //dividing our number by two
maxtab++; //+1 to max elements of the table
}
maxtab--; //-1 to max elements of the table (when dividing finishes it adds 1 additional elemnt that we don't want and it equal to 0)
a1 = a2; //we must do calculations one more time so we're gatting back our original number
table[0] = table[maxtab]; //we set the number of elements in our table to maxtab (we don't get 10 of 0's)
while (a1!=0) //same calculations 2nd time but adding every 1 or 0 (remainder) to separate element in table
{
remainder = a1%2; //getting a remainder
a1 = a1/2; //dividing by 2
table[tab] = remainder; //adding 0 or 1 to an element
tab++; //tab (element count) increases by 1 so next remainder is saved in another element
}
tab--; //same as with maxtab--
cout << "Your binary number: ";
while (tab>=0) //until we get to the 0 (1st) element of the table
{
cout << table[tab] << " "; //write the value of an element (0 or 1)
tab--; //decreasing by 1 so we show 0 and 1 FROM THE BACK (correct way)
}
cout << endl;
return 0;
}
Кстати, это сложно, но я старался изо всех сил.
edit - вот решение, в котором я закончил:
std::string toBinary(int n)
{
std::string r;
while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;}
return r;
}
Ответы
Ответ 1
std::bitset имеет метод .to_string(), который возвращает std::string, содержащее текстовое представление в двоичном формате, с заполнением нулевого нуля.
Выберите ширину битового набора по мере необходимости для ваших данных, например. std::bitset<32>, чтобы получить 32-символьные строки из 32-разрядных целых чисел.
#include <iostream>
#include <bitset>
int main()
{
std::string binary = std::bitset<8>(128).to_string(); //to binary
std::cout<<binary<<"\n";
unsigned long decimal = std::bitset<8>(binary).to_ulong();
std::cout<<decimal<<"\n";
return 0;
}
EDIT: Пожалуйста, не редактируйте мой ответ для Octal и Hexadecimal. OP специально попросил Decimal To Binary.
Ответ 2
Ниже приведена рекурсивная функция, которая принимает положительное целое число и выводит свои двоичные числа на консоль.
Алекс предположил, что для эффективности вы можете удалить printf() и сохранить результат в памяти... в зависимости от способа хранения результат может быть обращен вспять.
/**
* Takes a unsigned integer, converts it into binary and prints it to the console.
* @param n the number to convert and print
*/
void convertToBinary(unsigned int n)
{
if (n / 2 != 0) {
convertToBinary(n / 2);
}
printf("%d", n % 2);
}
Кредиты UoA ENGGEN 131
* Примечание. Преимущество использования целого без знака в том, что оно не может быть отрицательным.
Ответ 3
Вы можете использовать std:: bitset для преобразования числа в его двоичный формат.
Используйте следующий фрагмент кода:
std::string binary = std::bitset<8>(n).to_string();
Я нашел это в свойстве stackoverflow. Я прикрепляю ссылку .
Ответ 4
Довольно прямое решение для печати двоичного файла:
#include <iostream.h>
int main()
{
int num,arr[64];
cin>>num;
int i=0,r;
while(num!=0)
{
r = num%2;
arr[i++] = r;
num /= 2;
}
for(int j=i-1;j>=0;j--)
cout<<arr[j];
}
Ответ 5
An int переменная не находится в десятичной форме, она в двоичном формате. То, что вы ищете, представляет собой двоичное строковое представление числа, которое вы можете получить, применяя маску, которая фильтрует отдельные биты, а затем печатает их:
for( int i = sizeof(value)*CHAR_BIT-1; i>=0; --i)
cout << value & (1 << i) ? '1' : '0';
Это решение, если ваш вопрос является алгоритмическим. Если нет, вы должны использовать класс std:: bitset для обработки этого для вас:
bitset< sizeof(value)*CHAR_BIT > bits( value );
cout << bits.to_string();
Ответ 6
Нерекурсивное решение:
#include <iostream>
#include<string>
std::string toBinary(int n)
{
std::string r;
while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;}
return r;
}
int main()
{
std::string i= toBinary(10);
std::cout<<i;
}
Рекурсивное решение:
#include <iostream>
#include<string>
std::string r="";
std::string toBinary(int n)
{
r=(n%2==0 ?"0":"1")+r;
if (n / 2 != 0) {
toBinary(n / 2);
}
return r;
}
int main()
{
std::string i=toBinary(10);
std::cout<<i;
}
Ответ 7
Вот два подхода. Тот, который похож на ваш подход
#include <iostream>
#include <string>
#include <limits>
#include <algorithm>
int main()
{
while ( true )
{
std::cout << "Enter a non-negative number (0-exit): ";
unsigned long long x = 0;
std::cin >> x;
if ( !x ) break;
const unsigned long long base = 2;
std::string s;
s.reserve( std::numeric_limits<unsigned long long>::digits );
do { s.push_back( x % base + '0' ); } while ( x /= base );
std::cout << std::string( s.rbegin(), s.rend() ) << std::endl;
}
}
а другой использует std:: bitset, как предполагалось другими.
#include <iostream>
#include <string>
#include <bitset>
#include <limits>
int main()
{
while ( true )
{
std::cout << "Enter a non-negative number (0-exit): ";
unsigned long long x = 0;
std::cin >> x;
if ( !x ) break;
std::string s =
std::bitset<std::numeric_limits<unsigned long long>::digits>( x ).to_string();
std::string::size_type n = s.find( '1' );
std::cout << s.substr( n ) << std::endl;
}
}
Ответ 8
Вот современный вариант, который можно использовать для ints разных размеров.
#include <type_traits>
#include <bitset>
template<typename T>
std::enable_if_t<std::is_integral_v<T>,std::string>
encode_binary(T i){
return std::bitset<sizeof(T) * 8>(i).to_string();
}
Ответ 9
Вы хотите сделать что-то вроде:
cout << "Enter a decimal number: ";
cin >> a1;
cout << setbase(2);
cout << a1
Ответ 10
ДЕЦИМАЛЬНАЯ К БИНАРНЫМ НИКАКАЯ МАШИНА, ИСПОЛЬЗУЕМАЯ *, сделанная Оей:
Я все еще новичок, поэтому этот код будет использовать только циклы и переменные xD...
Надеюсь, вам понравится. Это, вероятно, можно сделать проще, чем это...
#include <iostream>
#include <cmath>
#include <cstdlib>
using namespace std;
int main()
{
int i;
int expoentes; //the sequence > pow(2,i) or 2^i
int decimal;
int extra; //this will be used to add some 0s between the 1s
int x = 1;
cout << "\nThis program converts natural numbers into binary code\nPlease enter a Natural number:";
cout << "\n\nWARNING: Only works until ~1.073 millions\n";
cout << " To exit, enter a negative number\n\n";
while(decimal >= 0){
cout << "\n----- // -----\n\n";
cin >> decimal;
cout << "\n";
if(decimal == 0){
cout << "0";
}
while(decimal >= 1){
i = 0;
expoentes = 1;
while(decimal >= expoentes){
i++;
expoentes = pow(2,i);
}
x = 1;
cout << "1";
decimal -= pow(2,i-x);
extra = pow(2,i-1-x);
while(decimal < extra){
cout << "0";
x++;
extra = pow(2,i-1-x);
}
}
}
return 0;
}
Ответ 11
здесь простой преобразователь, используя std::string в качестве контейнера. он позволяет отрицательное значение.
#include <iostream>
#include <string>
#include <limits>
int main()
{
int x = -14;
int n = std::numeric_limits<int>::digits - 1;
std::string s;
s.reserve(n + 1);
do
s.push_back(((x >> n) & 1) + '0');
while(--n > -1);
std::cout << s << '\n';
}
Ответ 12
Это более простая программа, чем когда-либо
//Program to convert Decimal into Binary
#include<iostream>
using namespace std;
int main()
{
long int dec;
int rem,i,j,bin[100],count=-1;
again:
cout<<"ENTER THE DECIMAL NUMBER:- ";
cin>>dec;//input of Decimal
if(dec<0)
{
cout<<"PLEASE ENTER A POSITIVE DECIMAL";
goto again;
}
else
{
cout<<"\nIT BINARY FORM IS:- ";
for(i=0;dec!=0;i++)//making array of binary, but reversed
{
rem=dec%2;
bin[i]=rem;
dec=dec/2;
count++;
}
for(j=count;j>=0;j--)//reversed binary is printed in correct order
{
cout<<bin[j];
}
}
return 0;
}
Ответ 13
На самом деле это очень простой способ сделать это. Мы используем рекурсивную функцию, которой задан номер (int) в параметре. Это довольно легко понять. Вы можете добавить и другие условия/варианты. Вот код:
int binary(int num)
{
int rem;
if (num <= 1)
{
cout << num;
return num;
}
rem = num % 2;
binary(num / 2);
cout << rem;
return rem;
}
Ответ 14
#include "stdafx.h"
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int main() {
// Initialize Variables
double x;
int xOct;
int xHex;
//Initialize a variable that stores the order if the numbers in binary/sexagesimal base
vector<int> rem;
//Get Demical value
cout << "Number (demical base): ";
cin >> x;
//Set the variables
xOct = x;
xHex = x;
//Get the binary value
for (int i = 0; x >= 1; i++) {
rem.push_back(abs(remainder(x, 2)));
x = floor(x / 2);
}
//Print binary value
cout << "Binary: ";
int n = rem.size();
while (n > 0) {
n--;
cout << rem[n];
} cout << endl;
//Print octal base
cout << oct << "Octal: " << xOct << endl;
//Print hexademical base
cout << hex << "Hexademical: " << xHex << endl;
system("pause");
return 0;
}
Ответ 15
#include <iostream>
using namespace std;
int main()
{
int a,b;
cin>>a;
for(int i=31;i>=0;i--)
{
b=(a>>i)&1;
cout<<b;
}
}
Ответ 16
HOPE YOU LIKE THIS SIMPLE CODE OF CONVERSION FROM DECIMAL TO BINARY
#include<iostream>
using namespace std;
int main()
{
int input,rem,res,count=0,i=0;
cout<<"Input number: ";
cin>>input;`enter code here`
int num=input;
while(input > 0)
{
input=input/2;
count++;
}
int arr[count];
while(num > 0)
{
arr[i]=num%2;
num=num/2;
i++;
}
for(int i=count-1 ; i>=0 ; i--)
{
cout<<" " << arr[i]<<" ";
}
return 0;
}
Ответ 17
std::string bin(uint_fast8_t i){return !i?"0":i==1?"1":bin(i/2)+(i%2?'1':'0');}
Ответ 18
// function to convert decimal to binary
void decToBinary(int n)
{
// array to store binary number
int binaryNum[1000];
// counter for binary array
int i = 0;
while (n > 0) {
// storing remainder in binary array
binaryNum[i] = n % 2;
n = n / 2;
i++;
}
// printing binary array in reverse order
for (int j = i - 1; j >= 0; j--)
cout << binaryNum[j];
}
см.: - https://www.geeksforgeeks.org/program-decimal-binary-conversion/
или используя функцию: -
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
cout<<bitset<8>(n).to_string()<<endl;
}
или используя левый сдвиг
#include<bits/stdc++.h>
using namespace std;
int main()
{
// here n is the number of bit representation we want
int n;cin>>n;
// num is a number whose binary representation we want
int num;
cin>>num;
for(int i=n-1;i>=0;i--)
{
if( num & ( 1 << i ) ) cout<<1;
else cout<<0;
}
}
Ответ 19
Для этого в C++ вы можете использовать функцию itoa(). Эта функция преобразует любое десятичное целое число в двоичное, десятичное, шестнадцатеричное и восьмеричное число.
#include<bits/stdc++.h>
using namespace std;
int main(){
int a;
char res[1000];
cin>>a;
itoa(a,res,10);
cout<<"Decimal- "<<res<<endl;
itoa(a,res,2);
cout<<"Binary- "<<res<<endl;
itoa(a,res,16);
cout<<"Hexadecimal- "<<res<<endl;
itoa(a,res,8);
cout<<"Octal- "<<res<<endl;return 0;
}
Однако он поддерживается только определенными компиляторами.
Вы также можете увидеть: itoa - C++ Ссылка
Ответ 20
Ниже приведен простой код C, который преобразует двоичный код в десятичный и обратно. Я написал это давно для проекта, в котором мишень была встроенный процессор и средство разработки были STDLIB, который был слишком большим для прошивки ПЗУ.
Это общий код C, который не использует библиотеку, не использует деление или оператор remainder (%) (что медленно на некоторых встроенных процессорах), а также не использует плавающую точку и не ищет таблицы и не ищет подражать любой арифметике BCD. Он использует тип long long, а точнее unsigned long long (или uint64), поэтому, если ваш встроенный процессор (и компилятор C, который идет с ним) не может выполнить 64-разрядную целочисленную арифметику, этот код не предназначен для ваше приложение. В противном случае, я думаю, что это C-код производственного качества (возможно, после замены long на int32 и unsigned long long на uint64). Я запустил эту ночь, чтобы проверить ее для каждых 2 ^ 32 целочисленных значений со знаком, и нет ошибки в преобразовании в любом направлении.
У нас был компилятор/компоновщик C, который мог генерировать исполняемые файлы, и нам нужно было делать то, что мы могли делать без stdlib (который был свиньей). Так что ни printf() ни scanf(). Ни sprintf() ни sscanf(). Но у нас все еще был пользовательский интерфейс, и мы должны были преобразовать числа base-10 в двоичные и обратно. (Мы также создали нашу собственную утилиту malloc() -like и наши собственные трансцендентные математические функции.)
Вот как я это сделал (main программа и вызовы stdlib были там для тестирования этой вещи на моем Mac, а не для встроенного кода). Кроме того, поскольку некоторые старые системы разработки не распознают int64 и uint64 и подобные типы, используются типы long long и unsigned long long которые предполагаются одинаковыми. И long предполагается равным 32 битам. Я предполагаю, что я мог бы typedef эд его.
// returns an error code, 0 if no error,
// -1 if too big, -2 for other formatting errors
int decimal_to_binary(char *dec, long *bin)
{
int i = 0;
int past_leading_space = 0;
while (i <= 64 && !past_leading_space) // first get past leading spaces
{
if (dec[i] == ' ')
{
i++;
}
else
{
past_leading_space = 1;
}
}
if (!past_leading_space)
{
return -2; // 64 leading spaces does not a number make
}
// at this point the only legitimate remaining
// chars are decimal digits or a leading plus or minus sign
int negative = 0;
if (dec[i] == '-')
{
negative = 1;
i++;
}
else if (dec[i] == '+')
{
i++; // do nothing but go on to next char
}
// now the only legitimate chars are decimal digits
if (dec[i] == '\0')
{
return -2; // there needs to be at least one good
} // digit before terminating string
unsigned long abs_bin = 0;
while (i <= 64 && dec[i] != '\0')
{
if ( dec[i] >= '0' && dec[i] <= '9' )
{
if (abs_bin > 214748364)
{
return -1; // this is going to be too big
}
abs_bin *= 10; // previous value gets bumped to the left one digit...
abs_bin += (unsigned long)(dec[i] - '0'); // ... and a new digit appended to the right
i++;
}
else
{
return -2; // not a legit digit in text string
}
}
if (dec[i] != '\0')
{
return -2; // not terminated string in 64 chars
}
if (negative)
{
if (abs_bin > 2147483648)
{
return -1; // too big
}
*bin = -(long)abs_bin;
}
else
{
if (abs_bin > 2147483647)
{
return -1; // too big
}
*bin = (long)abs_bin;
}
return 0;
}
void binary_to_decimal(char *dec, long bin)
{
unsigned long long acc; // 64-bit unsigned integer
if (bin < 0)
{
*(dec++) = '-'; // leading minus sign
bin = -bin; // make bin value positive
}
acc = 989312855LL*(unsigned long)bin; // very nearly 0.2303423488 * 2^32
acc += 0x00000000FFFFFFFFLL; // we need to round up
acc >>= 32;
acc += 57646075LL*(unsigned long)bin;
// (2^59)/(10^10) = 57646075.2303423488 = 57646075 + (989312854.979825)/(2^32)
int past_leading_zeros = 0;
for (int i=9; i>=0; i--) // maximum number of digits is 10
{
acc <<= 1;
acc += (acc<<2); // an efficient way to multiply a long long by 10
// acc *= 10;
unsigned int digit = (unsigned int)(acc >> 59); // the digit we want is in bits 59 - 62
if (digit > 0)
{
past_leading_zeros = 1;
}
if (past_leading_zeros)
{
*(dec++) = '0' + digit;
}
acc &= 0x07FFFFFFFFFFFFFFLL; // mask off this digit and go on to the next digit
}
if (!past_leading_zeros) // if all digits are zero ...
{
*(dec++) = '0'; // ... put in at least one zero digit
}
*dec = '\0'; // terminate string
}
#if 1
#include <stdlib.h>
#include <stdio.h>
int main (int argc, const char* argv[])
{
char dec[64];
long bin, result1, result2;
unsigned long num_errors;
long long long_long_bin;
num_errors = 0;
for (long_long_bin=-2147483648LL; long_long_bin<=2147483647LL; long_long_bin++)
{
bin = (long)long_long_bin;
if ((bin&0x00FFFFFFL) == 0)
{
printf("bin = %ld \n", bin); // this is to tell us that things are moving along
}
binary_to_decimal(dec, bin);
decimal_to_binary(dec, &result1);
sscanf(dec, "%ld", &result2); // decimal_to_binary() should do the same as this sscanf()
if (bin != result1 || bin != result2)
{
num_errors++;
printf("bin = %ld, result1 = %ld, result2 = %ld, num_errors = %ld, dec = %s \n",
bin, result1, result2, num_errors, dec);
}
}
printf("num_errors = %ld \n", num_errors);
return 0;
}
#else
#include <stdlib.h>
#include <stdio.h>
int main (int argc, const char* argv[])
{
char dec[64];
long bin;
printf("bin = ");
scanf("%ld", &bin);
while (bin != 0)
{
binary_to_decimal(dec, bin);
printf("dec = %s \n", dec);
printf("bin = ");
scanf("%ld", &bin);
}
return 0;
}
#endif
Ответ 21
#include <iostream>
#include <bitset>
#define bits(x) (std::string( \
std::bitset<8>(x).to_string<char,std::string::traits_type, std::string::allocator_type>() ).c_str() )
int main() {
std::cout << bits( -86 >> 1 ) << ": " << (-86 >> 1) << std::endl;
return 0;
}
Ответ 22
Мой способ преобразования десятичного числа в двоичное в C++. Но так как мы используем мод, эта функция будет работать и в шестнадцатеричном или восьмеричном виде. Вы также можете указать биты. Эта функция продолжает вычислять младший значащий бит и помещает его в конец строки. Если вы не очень похожи на этот метод, чем вы можете увидеть: https://www.wikihow.com/Convert-from-Decimal-to-Binary
#include <bits/stdc++.h>
using namespace std;
string itob(int bits, int n) {
int c;
char s[bits+1]; // +1 to append NULL character.
s[bits] = '\0'; // The NULL character in a character array flags the end of the string, not appending it may cause problems.
c = bits - 1; // If the length of a string is n, than the index of the last character of the string will be n - 1. Cause the index is 0 based not 1 based. Try yourself.
do {
if(n%2) s[c] = '1';
else s[c] = '0';
n /= 2;
c--;
} while (n>0);
while(c > -1) {
s[c] = '0';
c--;
}
return s;
}
int main() {
cout << itob(1, 0) << endl; // 0 in 1 bit binary.
cout << itob(2, 1) << endl; // 1 in 2 bit binary.
cout << itob(3, 2) << endl; // 2 in 3 bit binary.
cout << itob(4, 4) << endl; // 4 in 4 bit binary.
cout << itob(5, 15) << endl; // 15 in 5 bit binary.
cout << itob(6, 30) << endl; // 30 in 6 bit binary.
cout << itob(7, 61) << endl; // 61 in 7 bit binary.
cout << itob(8, 127) << endl; // 127 in 8 bit binary.
return 0;
}
Вывод:
0
01
010
0100
01111
011110
0111101
01111111
Ответ 23
Хорошо... Возможно, я немного новичок в C++, но я чувствую, что приведенные выше примеры не совсем правильно справляются с работой.
Вот мой взгляд на эту ситуацию.
char* DecimalToBinary(unsigned __int64 value, int bit_precision)
{
int length = (bit_precision + 7) >> 3 << 3;
static char* binary = new char[1 + length];
int begin = length - bit_precision;
unsigned __int64 bit_value = 1;
for (int n = length; --n >= begin; )
{
binary[n] = 48 | ((value & bit_value) == bit_value);
bit_value <<= 1;
}
for (int n = begin; --n >= 0; )
binary[n] = 48;
binary[length] = 0;
return binary;
}
@value = Значение, которое мы проверяем.
@bit_precision = Самый верхний левый бит, который нужно проверить.
@Length = Максимальный размер блока байтов. Например, 7 = 1 байт и 9 = 2 байт, но мы представляем это в виде битов, поэтому 1 байт = 8 бит.
@binary = просто какое-то глупое имя, которое я дал для вызова набора символов, которые мы устанавливаем. Мы установили статическое значение, чтобы оно не создавалось при каждом вызове. Для простого получения результата и его отображения тогда это работает хорошо, но если, скажем, вы хотите отобразить несколько результатов в пользовательском интерфейсе, все они будут отображаться как последний результат. Это можно исправить, удалив статический файл, но убедитесь, что вы удалите [] результаты, когда закончите с ним.
@begin = Это самый низкий показатель, который мы проверяем. Все, что находится за пределами этого пункта, игнорируется. Или, как показано во втором цикле, установите в 0.
Цикл @first - здесь мы устанавливаем значение 48 и в основном добавляем 0 или 1 к 48 на основе значения bool (value & bit_value) == bit_value. Если это правда, то char устанавливается на 49. Если это false, char устанавливается на 48. Затем мы сдвигаем значение bit_value или умножаем его на 2.
@второй цикл - здесь мы устанавливаем все индексы, которые мы игнорировали, равными 48 или '0'.
НЕКОТОРЫЕ ПРИМЕРНЫЕ ВЫХОДЫ !!!
int main()
{
int val = -1;
std::cout << DecimalToBinary(val, 1) << '\n';
std::cout << DecimalToBinary(val, 3) << '\n';
std::cout << DecimalToBinary(val, 7) << '\n';
std::cout << DecimalToBinary(val, 33) << '\n';
std::cout << DecimalToBinary(val, 64) << '\n';
std::cout << "\nPress any key to continue. . .";
std::cin.ignore();
return 0;
}
00000001 //Value = 2^1 - 1
00000111 //Value = 2^3 - 1.
01111111 //Value = 2^7 - 1.
0000000111111111111111111111111111111111 //Value = 2^33 - 1.
1111111111111111111111111111111111111111111111111111111111111111 //Value = 2^64 - 1.
СКОРОСТЬ ИСПЫТАНИЯ
Оригинальный вопрос Ответ: "Метод: toBinary (int);"
Выполнения: 10 000, Общее время (Милли): 4701,15, Среднее время (наносекунды): 470114
Моя версия: "Метод: DecimalToBinary (int, int);"
//Использование 64-битной точности.
Выполнения: 10 000 000, общее время (милли): 3386, среднее время (наносекунды): 338
//Используем точность 1 бит.
Выполнения: 10 000 000, общее время (милли): 634, среднее время (наносекунды): 63
Ответ 24
#include <iostream>
// x is our number to test
// pow is a power of 2 (e.g. 128, 64, 32, etc...)
int printandDecrementBit(int x, int pow)
{
// Test whether our x is greater than some power of 2 and print the bit
if (x >= pow)
{
std::cout << "1";
// If x is greater than our power of 2, subtract the power of 2
return x - pow;
}
else
{
std::cout << "0";
return x;
}
}
int main()
{
std::cout << "Enter an integer between 0 and 255: ";
int x;
std::cin >> x;
x = printandDecrementBit(x, 128);
x = printandDecrementBit(x, 64);
x = printandDecrementBit(x, 32);
x = printandDecrementBit(x, 16);
std::cout << " ";
x = printandDecrementBit(x, 8);
x = printandDecrementBit(x, 4);
x = printandDecrementBit(x, 2);
x = printandDecrementBit(x, 1);
return 0;
}
это простой способ получить двоичную форму типа int. кредит на learncpp.com. Я уверен, что это может быть использовано по-разному, чтобы добраться до одной и той же точки.
Ответ 25
При таком подходе десятичное число будет преобразовано в соответствующее двоичное число в строковом формате. строка возвращаемого типа выбрана, поскольку она может обрабатывать больший диапазон входных значений.
class Solution {
public:
string ConvertToBinary(int num)
{
vector<int> bin;
string op;
for (int i = 0; num > 0; i++)
{
bin.push_back(num % 2);
num /= 2;
}
reverse(bin.begin(), bin.end());
for (size_t i = 0; i < bin.size(); ++i)
{
op += to_string(bin[i]);
}
return op;
}
};
Ответ 26
Преобразование из натурального числа в двоичную строку:
string toBinary(int n) {
if (n==0) return "0";
else if (n==1) return "1";
else if (n%2 == 0) return toBinary(n/2) + "0";
else if (n%2 != 0) return toBinary(n/2) + "1";
}
Ответ 27
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
void Decimal2Binary(long value,char *b,int len)
{
if(value>0)
{
do
{
if(value==1)
{
*(b+len-1)='1';
break;
}
else
{
*(b+len-1)=(value%2)+48;
value=value/2;
len--;
}
}while(1);
}
}
long Binary2Decimal(char *b,int len)
{
int i=0;
int j=0;
long value=0;
for(i=(len-1);i>=0;i--)
{
if(*(b+i)==49)
{
value+=pow(2,j);
}
j++;
}
return value;
}
int main()
{
char data[11];//最後一個BIT要拿來當字串結尾
long value=1023;
memset(data,'0',sizeof(data));
data[10]='\0';//字串結尾
Decimal2Binary(value,data,10);
printf("%d->%s\n",value,data);
value=Binary2Decimal(data,10);
printf("%s->%d",data,value);
return 0;
}
