C++ - Conversion décimale en binaire
J'ai écrit un programme 'simple' (cela m'a pris 30 minutes) qui convertit le nombre décimal en binaire. Je suis SÛR qu'il existe un moyen beaucoup plus simple pour que vous puissiez me montrer? Voici le code:
#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;
}
Au fait c'est compliqué mais j'ai fait de mon mieux.
edit - Voici la solution que j'ai utilisée:
std::string toBinary(int n)
{
std::string r;
while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;}
return r;
}
std::bitset a une méthode .to_string() qui renvoie un std::string contenant une représentation textuelle en binaire, avec un remplissage à zéro.
Choisissez la largeur du jeu de bits nécessaire pour vos données, par exemple. std::bitset<32> pour obtenir des chaînes de 32 caractères à partir d'entiers 32 bits.
#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: S'il vous plaît, ne modifiez pas ma réponse pour Octal et Hexadecimal. L'OP a spécifiquement demandé Decimal To Binary.
Ce qui suit est une fonction récursive qui prend un entier positif et affiche ses chiffres binaires sur la console.
Alex a suggéré, pour plus d'efficacité, de supprimer printf() et de stocker le résultat en mémoire ... en fonction de la méthode de stockage, le résultat pourrait être inversé.
/**
* Takes a positive 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);
}
Crédits à UoA ENGGEN 131
* Note: L'utilisation d'un unsigned int a l'avantage de ne pas être négatif.
Vous pouvez utiliser std :: bitset pour convertir un nombre en son format binaire.
Utilisez l'extrait de code suivant:
std::string binary = std::bitset<8>(n).to_string();
J'ai trouvé cela sur stackoverflow lui-même. Je joins le link .
Une solution assez simple pour imprimer en binaire:
#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];
}
Solution non récursive:
#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;
}
Solution récursive:
#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;
}
Une variable int n'est pas en décimal, mais en binaire. Ce que vous recherchez est une représentation sous forme de chaîne binaire du nombre, que vous pouvez obtenir en appliquant un masque qui filtre les bits individuels, puis en les imprimant:
for( int i = sizeof(value)*CHAR_BIT-1; i>=0; --i)
cout << value & (1 << i) ? '1' : '0';
C'est la solution si votre question est algorithmique. Sinon, vous devriez utiliser la classe std :: bitset pour gérer cela pour vous:
bitset< sizeof(value)*CHAR_BIT > bits( value );
cout << bits.to_string();
Voici deux approches. L'un est similaire à votre approche
#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;
}
}
et l'autre utilise std :: bitset comme d'autres l'ont suggéré.
#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;
}
}
voici un convertisseur simple utilisant std::string comme conteneur. cela permet une valeur négative.
#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';
}
#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;
}
Ma façon de convertir décimal en binaire en C++. Mais puisque nous utilisons mod, cette fonction fonctionnera également en cas d’hexadécimal ou d’octal. Vous pouvez également spécifier des bits. Cette fonction continue à calculer le bit significatif le plus bas et à le placer à la fin de la chaîne. Si vous n'êtes pas aussi proche de cette méthode que vous ne pouvez le voir: 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;
}
Le résultat:
0
01
010
0100
01111
011110
0111101
01111111
#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;
}
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;
}
DÉCIMAL À BINAIRE PAS DE RÉSEAUX UTILISÉS * fabriqué par Oya:
Je suis encore débutant, ce code n'utilisera que des boucles et des variables xD ...
J'espère que vous aimez. Cela peut probablement être simplifié ...
#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;
}
Ci-dessous, un code C simple qui convertit le binaire en décimal et inversement. Je l'ai écrit il y a longtemps pour un projet dans lequel la cible était un processeur intégré et les outils de développement avaient une stdlib qui était moyen trop volumineux pour la ROM du microprogramme.
Il s’agit d’un code C générique qui n’utilise aucune bibliothèque, ni la division ni l’opérateur restant (%) (ce qui est lent sur certains processeurs intégrés), ni aucun virgule flottante, ni aucune recherche dans une table, ni aucune recherche de table. imiter n'importe quelle arithmétique BCD. Son utilisation est le type long long, plus spécifiquement unsigned long long (ou uint64), donc si votre processeur intégré (et le compilateur C qui l'accompagne) ne peut pas effectuer d'arithmétique sur un entier de 64 bits, ce code n'est pas destiné à votre application. Sinon, je pense que c'est du code C de qualité de production (peut-être après avoir changé long en int32 et unsigned long long en uint64). J'ai exécuté cette nuit pour le tester pour chaque 2 ^ 32 valeurs entières signées et il n'y a pas d'erreur de conversion dans les deux sens.
Nous avions un compilateur/lieur C capable de générer des exécutables et nous devions faire ce que nous pouvions faire sans aucune stdlib (qui était un cochon). Donc, ni printf() ni scanf(). Pas même une sprintf() ni sscanf(). Mais nous encore avions une interface utilisateur et devions convertir des nombres en base 10 en fichiers binaires et inversement. (Nous avons également créé notre propre utilitaire semblable à malloc()- ainsi que nos propres fonctions de calcul transcendantal.)
C'est donc comme cela que je l'ai fait (le programme main et les appels à stdlib étaient là pour tester cette chose sur mon mac, pas pour le code incorporé). De plus, étant donné que certains systèmes de développement plus anciens ne reconnaissent pas "int64" et "uint64" et les types similaires, les types long long et unsigned long long sont utilisés et supposés être les mêmes. Et long est supposé être de 32 bits. Je suppose que j'aurais pu typedefed.
// 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>
using namespace std;
int main()
{
int a,b;
cin>>a;
for(int i=31;i>=0;i--)
{
b=(a>>i)&1;
cout<<b;
}
}
Vous voulez faire quelque chose comme:
cout << "Enter a decimal number: ";
cin >> a1;
cout << setbase(2);
cout << a1
Ok. Je suis peut-être un peu nouveau en C++, mais j’ai le sentiment que les exemples ci-dessus ne permettent pas de faire le travail correctement.
Voici mon point de vue sur cette situation.
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 = La valeur que nous vérifions.
@bit_precision = Le bit le plus à gauche le plus à vérifier.
@Length = La taille maximale du bloc d'octets. Par exemple. 7 = 1 octet et 9 = 2 octets, mais nous représentons cela sous forme de bits, donc 1 octet = 8 bits.
@binary = juste un nom idiot que j'ai donné pour appeler le tableau de caractères que nous définissons. Nous avons réglé ce paramètre sur statique afin qu'il ne soit pas recréé à chaque appel. Pour obtenir simplement un résultat et l'afficher, cela fonctionne bien, mais si vous vouliez afficher plusieurs résultats sur une interface utilisateur, ils s'afficheraient tous comme le dernier résultat. Vous pouvez résoudre ce problème en supprimant les parasites, mais assurez-vous de supprimer [] les résultats lorsque vous avez terminé.
@begin = Ceci est l'indice le plus bas que nous vérifions. Tout ce qui dépasse ce point est ignoré. Ou comme indiqué dans la 2ème boucle définie sur 0.
@first loop - Ici, nous définissons la valeur sur 48 et ajoutons en gros 0 ou 1 à 48 en fonction de la valeur booléenne de (valeur & valeur_ bits) == valeur_ bits. Si cela est vrai, le caractère est défini sur 49. Si cela est faux, le caractère est défini sur 48. Ensuite, nous décalons la valeur de bit ou, en gros, nous le multiplions par 2.
@second loop - Ici, nous définissons tous les index ignorés à 48 ou à «0».
QUELQUES EXEMPLES DE SORTIES !!!
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.
ESSAIS DE VITESSE
Réponse de la question d'origine: "Méthode: toBinary (int);"
Exécutions: 10.000, Temps total (Milli): 4701.15, Temps moyen (Nanosecondes): 470114
Ma version: "Méthode: DecimalToBinary (int, int);"
// Utilisation de la précision 64 bits.
Exécutions: 10.000.000, Temps total (Milli): 3386, Temps moyen (Nanosecondes): 338
// Utilisation de la précision à 1 bit.
Exécutions: 10.000.000, Temps total (Milli): 634, Temps moyen (Nanosecondes): 63
C'est plus simple programme que jamais
//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;
}
Il existe en fait un moyen très simple de le faire. Nous utilisons une fonction récursive qui se voit attribuer le nombre (int) dans le paramètre. C'est assez facile à comprendre. Vous pouvez également ajouter d'autres conditions/variations. Voici le code:
int binary(int num)
{
int rem;
if (num <= 1)
{
cout << num;
return num;
}
rem = num % 2;
binary(num / 2);
cout << rem;
return rem;
}
std::string bin(uint_fast8_t i){return !i?"0":i==1?"1":bin(i/2)+(i%2?'1':'0');}
Pour cela, vous pouvez utiliser la fonction itoa () en C++. Cette fonction convertit tout entier décimal en nombre binaire, décimal, hexadécimal et octal.
#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;
}
Cependant, il n’est supporté que par des compilateurs spécifiques.
Vous pouvez voir aussi: itoa - Référence C++
#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;
}
c'est un moyen simple d'obtenir la forme binaire d'un int. crédit à learncpp.com. Je suis sûr que cela pourrait être utilisé de différentes manières pour arriver au même point.
// 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];
}
voir: - https://www.geeksforgeeks.org/program-decimal-binary-conversion/
ou en utilisant la fonction: -
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;cin>>n;
cout<<bitset<8>(n).to_string()<<endl;
}
ou en utilisant le décalage gauche
#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;
}
}
Dans cette approche, la décimale sera convertie en nombre binaire respectif dans le format de chaîne. Le type type de retour de chaîne est choisi car il peut gérer une plus grande plage de valeurs d'entrée.
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;
}
};
Voici une variante moderne qui peut être utilisée pour ints de différentes tailles.
#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();
}