it-swarm.com.de

C++ - Konvertierung von Dezimal nach Binär

Ich schrieb ein "einfaches" Programm (es dauerte 30 Minuten), das Dezimalzahlen in Binärzahlen konvertiert. Ich bin sicher, dass es einen viel einfacheren Weg gibt, also können Sie mir das zeigen?

#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;
}

Übrigens ist es kompliziert, aber ich habe mein Bestes gegeben.

edit - Hier ist die Lösung, mit der ich endete:

std::string toBinary(int n)
{
    std::string r;
    while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;}
    return r;
}
51
user3478487

std::bitset hat eine .to_string()-Methode, die einen std::string zurückgibt, der eine Textdarstellung im Binärformat enthält, wobei die Nullen aufgefüllt werden.

Wählen Sie die für Ihre Daten erforderliche Breite des Bitsets, z. std::bitset<32>, um 32-stellige Zeichenfolgen aus 32-Bit-Ganzzahlen zu erhalten.

#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: Bitte bearbeiten Sie meine Antwort nicht für Oktal und Hexadezimal. Das OP hat speziell nach Dezimal nach Binär gefragt.

99
Brandon

Das Folgende ist eine rekursive Funktion, die eine positive Ganzzahl annimmt und ihre Binärziffern an die Konsole ausgibt.

Alex schlug vor, aus Gründen der Effizienz sollten Sie printf() entfernen und das Ergebnis im Arbeitsspeicher speichern. Je nach Speichermethoden kann das Ergebnis umgekehrt werden.

/**
 * 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);
}

Gutschriften an UoA ENGGEN 131

* Hinweis: Der Vorteil der Verwendung eines vorzeichenlosen int ist, dass es nicht negativ sein kann.

43
Pathfinder

Sie können std :: bitset verwenden, um eine Zahl in ihr Binärformat zu konvertieren.

Verwenden Sie das folgende Code-Snippet:

std::string binary = std::bitset<8>(n).to_string();

Ich habe das auf stackoverflow selbst gefunden. Ich füge das link hinzu.

8
skpro19

Eine ziemlich einfache Lösung zum Binärdruck: 

#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];
}
7
piyushtechsavy

Nicht rekursive Lösung:

#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;
}

Rekursive Lösung:

#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;
}
4
abe312

Eine Variable int ist nicht dezimal, sondern binär. Was Sie suchen, ist eine binäre Zeichenfolgendarstellung der Zahl, die Sie erhalten, indem Sie eine Maske anwenden, die einzelne Bits filtert, und diese dann drucken:

for( int i = sizeof(value)*CHAR_BIT-1; i>=0; --i)
    cout << value & (1 << i) ? '1' : '0';

Das ist die Lösung, wenn Ihre Frage algorithmisch ist. Wenn nicht, sollten Sie die Klasse std :: bitset verwenden, um dies für Sie zu erledigen:

bitset< sizeof(value)*CHAR_BIT > bits( value );
cout << bits.to_string();
4
Alex

Hier sind zwei Ansätze. Der eine ist Ihrem Ansatz ähnlich 

#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;
    }
}

und die anderen verwenden std :: bitset, wie von anderen vorgeschlagen.

#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;
    }
}
3

hier ein einfacher Konverter mit std::string als Container. es erlaubt einen negativen Wert.

#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';
}
0
MORTAL
#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;
}
0
Yuriy Gyerts

Meine Art der Konvertierung von Dezimal in Binär in C++. Da wir jedoch mod verwenden, funktioniert diese Funktion auch im Fall von Hexadezimal oder Oktal. Sie können auch Bits angeben. Diese Funktion berechnet das niedrigstwertige Bit und platziert es am Ende der Zeichenfolge. Wenn Sie dieser Methode nicht so ähnlich sind, können Sie sie besuchen: 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;
}

Die Ausgabe:

0
01
010
0100
01111
011110
0111101
01111111
0
#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;
}
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;
    }
0
A.siddiqui

DECIMAL TO BINARY KEINE ANGEBOTE * von Oya:

Ich bin noch ein Anfänger, daher werden in diesem Code nur Schleifen und Variablen xD verwendet ...

Hoffe du magst es. Dies kann wahrscheinlich einfacher gemacht werden als es ist ...

    #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;
    }
0
João

Unten ist ein einfacher C-Code, der Binärdaten in Dezimalzahlen und wieder zurück konvertiert. Ich habe es vor langer Zeit für ein Projekt geschrieben, in dem das Ziel ein eingebetteter Prozessor war und die Entwicklungstools eine stdlib hatten, die way zu groß für das Firmware-ROM war.

Dies ist generischer C-Code, der weder eine Bibliothek noch eine Division oder den Restoperator (%) (der bei einigen eingebetteten Prozessoren langsam ist) verwendet, noch Gleitkommazahlen verwendet oder Tabellen nachschlägt Emulieren Sie eine beliebige BCD-Arithmetik. Was es nutzt, ist der Typ long long, Genauer unsigned long long (Oder uint64), Falls Ihr eingebetteter Prozessor (und der dazugehörige C-Compiler) dies nicht kann Wenn Sie eine 64-Bit-Ganzzahl-Arithmetik ausführen, ist dieser Code nicht für Ihre Anwendung geeignet. Ansonsten denke ich, dass dies C-Code in Produktionsqualität ist (möglicherweise nachdem long in int32 Und unsigned long long In uint64 Geändert wurden). Ich habe dies über Nacht ausgeführt, um es für jeweils 2 ^ 32 vorzeichenbehaftete Ganzzahlwerte zu testen, und es gibt keinen Fehler bei der Konvertierung in beide Richtungen.

Wir hatten einen C-Compiler/Linker, der ausführbare Dateien generieren konnte, und wir mussten das tun, was wir konnten , ohne eine stdlib (die ein Schwein war). Also kein printf() noch scanf(). Weder eine sprintf() noch eine sscanf(). Aber wir hatten noch eine Benutzeroberfläche und mussten 10er-Zahlen in Binär- und Rückwärtszahlen konvertieren. (Wir haben auch unser eigenes malloc() - ähnliches Hilfsprogramm erfunden und auch unsere eigenen transzendentalen mathematischen Funktionen.)

So habe ich es gemacht (das Programm main und Aufrufe von stdlib waren da, um dieses Ding auf meinem Mac zu testen, nicht für den eingebetteten Code). Da einige ältere Entwicklungssysteme "int64" Und "uint64" Und ähnliche Typen nicht erkennen, werden die Typen long long Und unsigned long long Und verwendet als gleich angenommen. Und long wird mit 32 Bit angenommen. Ich denke, ich hätte es typedef ändern können.

// 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;
    }
}

Sie möchten etwas tun wie:

cout << "Enter a decimal number: ";
cin >> a1;
cout << setbase(2);
cout << a1
0
JoeNahmias

Okay .. Ich bin vielleicht ein bisschen neu in C++, aber ich denke, dass die obigen Beispiele die Arbeit nicht ganz richtig machen.

Hier ist meine Meinung zu dieser 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 = Der Wert, den wir prüfen.

@bit_precision = Das oberste linke Bit, nach dem gesucht werden soll.

@Length = Die maximale Byteblockgröße. Z.B. 7 = 1 Byte und 9 = 2 Byte, aber wir stellen dies in Form von Bits dar, also 1 Byte = 8 Bits.

@binary = nur ein dummer Name, den ich gegeben habe, um das Array von Zeichen aufzurufen, das wir einstellen. Wir haben dies auf statisch gesetzt, damit es nicht bei jedem Anruf neu erstellt wird. Wenn Sie einfach ein Ergebnis abrufen und anzeigen möchten, funktioniert dies gut, wenn Sie jedoch mehrere Ergebnisse auf einer Benutzeroberfläche anzeigen möchten, werden alle als letztes Ergebnis angezeigt. Sie können dies beheben, indem Sie statisch entfernen. Stellen Sie jedoch sicher, dass Sie die Ergebnisse löschen [], wenn Sie damit fertig sind. 

@begin = Dies ist der niedrigste Index, den wir überprüfen. Alles, was über diesen Punkt hinausgeht, wird ignoriert. Oder wie in der 2. Schleife auf 0 eingestellt.

@ Erste Schleife - Hier setzen wir den Wert auf 48 und addieren im Grunde eine 0 oder 1 bis 48, basierend auf dem Bool-Wert von (Wert & Bitwert) == Bitwert. Wenn dies wahr ist, ist das Zeichen auf 49 gesetzt. Wenn dies falsch ist, wird das Zeichen auf 48 gesetzt. Dann verschieben wir den Wert von bit_value oder multiplizieren ihn grundsätzlich mit 2.

@second loop - Hier setzen wir alle Indizes, die wir ignoriert haben, auf 48 oder '0'.

EINIGE BEISPIELAUSGABEN !!!

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.

GESCHWINDIGKEITSPRÜFUNGEN  

Antwort der Originalfrage: "Methode: toBinary (int);"

Ausführungen: 10.000, Gesamtzeit (Milli): 4701,15, Durchschnittszeit (Nanosekunden): 470114

Meine Version: "Methode: DecimalToBinary (int, int);"

// 64-Bit-Genauigkeit verwenden.

Ausführungen: 10.000.000, Gesamtzeit (Milli): 3386, Durchschnittszeit (Nanosekunden): 338

// 1-Bit-Genauigkeit verwenden.

Ausführungen: 10.000.000, Gesamtzeit (Milli): 634, Durchschnittszeit (Nanosekunden): 63

0
Jeremy Trifilo

Dies ist ein mehr einfaches Programm als je zuvor

//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; 
}
0
Sonani Meet

Es gibt tatsächlich einen sehr einfachen Weg, dies zu tun. Was wir tun, ist die Verwendung einer rekursiven Funktion, deren Nummer (int) im Parameter angegeben ist. Es ist ziemlich leicht zu verstehen. Sie können auch andere Bedingungen/Variationen hinzufügen. Hier ist der Code:

int binary(int num)
{
    int rem;
    if (num <= 1)
        {
            cout << num;
            return num;
        }
    rem = num % 2;
    binary(num / 2);
    cout << rem;
    return rem;
}
0
Sahil Shah
std::string bin(uint_fast8_t i){return !i?"0":i==1?"1":bin(i/2)+(i%2?'1':'0');}
0
q-l-p

In C++ können Sie die itoa () - Funktion verwenden. Diese Funktion konvertiert eine beliebige Dezimalzahl in eine Binär-, Dezimal-, Hexadezimal- und Oktalzahl.

#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;
}

Es wird jedoch nur von bestimmten Compilern unterstützt.

Sie können auch sehen: itoa - C++ - Referenz

0
Abhijoy Sarkar
#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;
}

dies ist eine einfache Methode, um die binäre Form eines Int zu erhalten. Kredit an learncpp.com. Ich bin mir sicher, dass dies auf verschiedene Arten verwendet werden kann, um zum selben Punkt zu gelangen.

0
dkpaintball8488
// 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];
}

referenz: - https://www.geeksforgeeks.org/program-decimal-binary-conversion/

oder mit der Funktion: -

#include<bits/stdc++.h>
using namespace std;

int main()
{

    int n;cin>>n;
    cout<<bitset<8>(n).to_string()<<endl;


}

oder mit Linksverschiebung

#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;
    }


}
0
mjp

Bei diesem Ansatz wird die Dezimalzahl in die entsprechende Binärzahl im Zeichenfolgenformat konvertiert. Der String-Rückgabetyp wird ausgewählt, da er einen größeren Bereich von Eingabewerten verarbeiten kann.

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;
  }
};
0
Ganesh M S

Hier ist eine moderne Variante, die für ints verschiedener Größen verwendet werden kann.

#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();
}
0