Я написал 'простую' (это заняло у меня 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's 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's 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's and 1's FROM THE BACK (correct way)
}
cout << endl;
return 0;
}
Кстати, он сложный, но я старался изо всех сил.
Редактирование - Вот решение, которое я в итоге использовал:
std::string toBinary(int n)
{
std::string r;
while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;}
return r;
}
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: Пожалуйста, не редактируйте мой ответ для восьмеричной и шестнадцатеричной систем. ОП конкретно спрашивал о десятичной системе счисления в двоичную.
Ниже рекурсивная функция, которая принимает положительное целое число и печатает его двоичное число в консоль.
Алекс предложил, для повышения эффективности, вы можете удалить `функции 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);
}
Кредиты на Уоа ENGGEN 131
*Примечание: преимущество использования беззнаковый инт является то, что он может'т быть отрицательным.
Вы можете использовать std::bitset для преобразования числа в его двоичном формате.
Используйте следующий фрагмент кода:
std::string binary = std::bitset<8>(n).to_string();
Я нашла это на сайте StackOverflow себя. Я прилагаю ссылка.
Довольно прямо вперед, решение печатать двоичные:
#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];
}
Не рекурсивное решение:
#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;
}
Переменная 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();
Здесь два подхода. Один похож на ваш подход
#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;
}
}
Вот современный вариант, который можно использовать для целых чисел различных размеров.
#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();
}
// 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;
}
или используя левый Shift
#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;
}
}
Для этого , в C++ можно использовать сделан вывод (функции).Эта функция преобразовать любое десятичное число в двоичное, десятичное , шестнадцатеричное и восьмеричное число.
#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;
}
Однако, это только поддерживается конкретными компиляторами.
Вы можете Смотрите также: был сделан вывод - [ссылки c++] (http://www.cplusplus.com/reference/cstdlib/itoa/)
Ниже приведен простой код на языке C, которая преобразует двоичный в десятичный и обратно. Я это писал давно для проекта, в котором был встроенный процессор и инструменты развития stdlib, что на пути слишком велик для прошивки ПЗУ.
Это универсальный код, который не использует какие-либо библиотеки, а также не использовать деление или остаток (%) оператора (который является медленным на некоторых встроенных процессоров), а также не использовать любые плавающей точкой, а также не использовать любые таблицы подстановки, ни эмулировать любой арифметики BCD. Что он делает использование типа длинный
, точнее неподписанные долго долго "(или " тип uint64
), так что если ваш встроенный процессор (и компилятор C, который идет с ним) не может делать 64-битной целочисленной арифметики, этот код не для вашего приложения. В противном случае, я думаю, что это качество производства код C (возможно, после изменения долго
до типа int32
и неподписанные долго долго " на " типа uint64
). Я бежал всю ночь, чтобы проверить его для каждого 2^32 целочисленных значений со знаком, и нет никакой ошибки в преобразование в любом направлении.
У нас был компилятор/линкер, который может генерировать исполняемые файлы, и мы должны делать то, что мы можем сделать без любой stdlib (которая была свинья). Так нет функции printf ()
, ни функции scanf()
. Даже не для себя функции sprintf (), ни
использования sscanf(). Но мы **еще** имел пользовательский интерфейс и пришлось конвертировать базу-10 чисел в двоичные и обратно. (Мы также придумали свой собственный функция
malloc()`-вроде утилита также и наши собственные трансцендентные математические функции тоже.)
Так что это был, как я это сделал ("основную" программу и призывает stdlib были там для тестирования этой штуки на моем Mac, не для встроенного кода). Также, потому что некоторые старые разработки систем Дон'т признают "В тип int64
" и "uint64 в
" и похожие типы, которые длинный
и неподписанные долго долго используются и предполагаются одинаковыми. И "длинные" считается 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
#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;
}
Мой способ преобразования десятичных чисел в двоичное в C++. Но так как мы используем мод, эта функция будет работать в случае шестнадцатеричной или восьмеричной также. Вы также можете указать бит. Эта функция вычисления самой низкой бита и поместить его на конце строки. Если вы не так похож на этот метод, чем вы можете вист: https://www.wikihow.com/Convert-from-Decimal-to-Binary ``СРР
с помощью пространства имен std;
строки itob(инт бит, инт Н) { инт с; тип char с[бит+1]; // +1, чтобы добавить нулевой символ.
с[Бит] = '\0'; // нулевой символ в массив символов, флагов конца строки, не дописывание это может вызвать проблемы.
с = бит - 1; // Если длина строки n, то индекс последнего символа строки будет равно N - 1. Причиной индекса 0 основан не 1 на основе. Попробовать себя.
делать { если(N%2) С[с] = '1'; еще с[с] = '0'; н /= 2; с--; } а (п>0);
а(с > -1) { с[с] = '0'; с--; }
возврат с; }
тап_п() { соиь << itob(1, 0) И Л;< епси; // 0 в 1 разрядное двоичное. соиь << itob(2, 1) << епси; // 1 в 2-х разрядное двоичное. соиь << itob(3, 2) << епси; // 2 в 3-х разрядное двоичное. соиь << itob(4, 4) << епси; // 4 в 4-х разрядное двоичное. соиь << itob(5, 15) << епси; // 15 в 5-ти разрядный двоичный. соиь << itob(6, 30) в << епси; // 30 в 6-разрядный двоичный. соиь << itob(7, 61) на << епси; // 61 в 7-битный двоичный. соиь << itob(8, 127) << епси; // 127 в 8-битовое двоичное. возврат 0; } ``
Вывод:
0 01 010 0100 01111 011110 0111101 01111111
Ладно.. возможно я немного нового для 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;
}
@значение = значение, которое мы проверяем.
@bit_precision = высшая осталось всего немного, чтобы проверить.
@Длина = Максимальная Байт Размера Блока. Е. Г. 7 = 1 байт, а 9 = 2 байта, но мы представляем это в виде бита, 1 байт = 8 бит.
@двоичной = просто какое-то глупое имя, которое я дал называть массив символов, которые мы ставим. Мы устанавливаем это для статических, так что он выиграл'т быть воссозданы при каждом вызове. Для того, чтобы просто получить результат и отобразить его, то это работает хорошо, но если позвольте'говорят, что вы хотели отображать несколько результатов в интерфейсе они все появляются в качестве последнего результата. Это может быть исправлено путем удаления статических, но убедитесь, что вы удалите [] результаты, когда вы сделали с ним.
@начать = это самый низкий показатель, что мы проверяем. Все за этот момент игнорируется. Или, как показано на 2-й петле равен 0.
@первый цикл - здесь мы устанавливаем значение 48, а в принципе добавить 0 или 1 до 48, основанные на значение bool (значение & bit_value) == bit_value. Если это правда, чар находится в 49. Если это ложные чар находится в 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(Инт); и"
Исполнение: 10,000 , Общее Время (Милли): 4701.15 , Среднее Время (Наносекунды): 470114
Мой вариант: "по методу: DecimalToBinary(инт, Инт); и"
//С Использованием 64-Битной Точности.
Исполнение: 10,000,000 , Общее Время (Милли): 3386 , Среднее Время (Наносекунды): 338
//Используя 1 Бит Точности.
Исполнение: 10,000,000, Общее Время (Милли): 634, Среднее Время (Наносекунды): 63
#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;
}
это простой способ получить двоичная форма инт. кредит learncpp.com. я уверен, что это может быть использован в различных способов, чтобы добраться до той же точки.
Преобразование из натурального числа в двоичную строку:
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";
}
Десятичных чисел в двоичные массивы не используется *сделано Ойя:
Я'м все еще новичок, поэтому этот код будет использовать только циклы и переменные хD...
Надеюсь, вам понравится. Это, наверное, можно сделать проще, чем это...
#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;
}
вот простой конвертер с использованием СТД::строка` в качестве контейнера. это позволяет отрицательное значение.
#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';
}
Это больше просто программы, чем когда-либо
//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's 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;
}