C ++ - Konvertierung von Dezimal zu Binär

77

Ich habe ein 'einfaches' Programm geschrieben (es hat 30 Minuten gedauert), das die Dezimalzahl in eine Binärzahl umwandelt. Ich bin mir sicher, dass es einen viel einfacheren Weg gibt. Können Sie es mir zeigen? Hier ist der 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;
}

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

edit - Hier ist die Lösung, die ich letztendlich verwendet habe:

std::string toBinary(int n)
{
    std::string r;
    while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;}
    return r;
}
user3478487
quelle
3
int value = (some value); for (int i = (sizeof(value)*8)-1; i <= 0; i--) { cout << (value & (1 << i)) ? '1' : '0'; } cout << endl;
Mah
Wickeln Sie all dies in eine Funktion wie std::string ToBinary(int decimal), dann wird es in Zukunft einfach sein :)
Christian Hackl
Dort gibt es keine Dezimalstelle. Sie sollten das zuerst verstehen, bevor Sie mit Basen spielen.
Slava
Es sollte eine Saite sein, keine Leere
Wilhelm Erasmus
Ihre 'Lösung' wird nicht kompiliert. Ihre Funktion gibt eine Zeichenfolge zurück, aber die Signatur der Funktion gibt an, dass nichts zurückgegeben wird.
Jonathan Leffler

Antworten:

150

std::bitsethat eine .to_string()Methode, die ein std::stringHalten einer Textdarstellung in Binärform mit einem Abstand von Null vorgibt.

Wählen Sie die Breite des Bitsets nach Bedarf für Ihre Daten, z. B. std::bitset<32>um 32-Zeichen-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;
}

BEARBEITEN: Bitte bearbeiten Sie meine Antwort für Oktal und Hexadezimal nicht. Das OP forderte ausdrücklich Decimal To Binary an.

Brandon
quelle
@brandon aber funktioniert dies für eine Nummer größer als 256
sql_dummy
1
@sql_dummy ja. Geben Sie anstelle von 8 Bits eine größere Zahl an. Versuchen Sie stattdessen 32.
Brandon
2
Für die Suche nach Hexadezimal - Conversions, zu verwenden: itoa: cplusplus.com/reference/cstdlib/itoa
Brandon
Was ist, wenn die Bitgröße zur Kompilierungszeit nicht angegeben werden kann?
Cuhrazatee
@Cuhrazatee geben Sie dann die größte Bitgröße an, die Sie können. std::size_t
Brandon
48

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

Aus Gründen der Effizienz schlug Alex vor, printf()das Ergebnis zu entfernen und im Speicher zu speichern. Je nach Speichermethode kann das Ergebnis umgekehrt werden.

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

Credits an UoA ENGGEN 131

* Hinweis: Der Vorteil der Verwendung eines int ohne Vorzeichen besteht darin, dass es nicht negativ sein kann.

Pfadfinder
quelle
6
Möglicherweise möchten Sie den nParameter zu einem machen, unsigned intda die Funktion für negative Zahlen nicht richtig funktioniert.
Alex
Ein separater printfAnruf für jedes Bit ist ziemlich schrecklich. Das "hocheffizient" ist Sarkasmus, oder?
Peter Cordes
@ Peter Cordes Ich wünschte, es wäre Sarkasmus, aber als erstes Jahr an der Uni ist es oft nicht so. Willst du es mit say .. Bit Shifting ändern? Ich werde die Beschreibung von "hocheffizient" auf "leicht codierbar" aktualisieren.
Pathfinder
@ Pathfinder: Ja, die optimale Lösung für Effizienz ist wahrscheinlich so, wie ich es in einem Kommentar zu einer anderen Antwort beschrieben habe . Da die Zeichenfolgenlänge eine Konstante zur Kompilierungszeit (die Breite des Typs) ist, können Sie einfach eine erstellen char buf[CHAR_BIT*sizeof(unsigned)]. Durchlaufen Sie die Schleife, während Sie die Bits in der Ganzzahl mit einer Shift + Maske durchlaufen. '0' + 1ist '1'für ASCII, UTF8 und jeden anderen vernünftigen Zeichensatz, sodass Sie '0' + (n&1)eine Ziffer erhalten können.
Peter Cordes
Wie auch immer, einen Puffer zu füllen und printf einmal aufzurufen, ist ein großer Gewinn, wenn man ihn 32 Mal aufruft. Außerdem möchten Sie es nicht immer direkt drucken. manchmal willst du etwas anderes damit machen.
Peter Cordes
13

Mit std :: bitset können Sie eine Zahl in ihr Binärformat konvertieren.

Verwenden Sie das folgende Codefragment:

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

Ich habe dies beim Stackoverflow selbst gefunden. Ich hänge den Link an .

skpro19
quelle
4
Mehr oder weniger ein Duplikat der akzeptierten Antwort .
Peter Cordes
10

Eine ziemlich einfache Lösung zum Drucken von Binärdateien:

#include <iostream>
using namespace std;
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];
  }
}
piyushtechsavy
quelle
es ersparte mir viel Kopfschmerzen.
Moh Vahedi
5

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;
}
abe312
quelle
1
Sie sollten stattdessen eine Bitverschiebung verwenden /=2, oder die unsignedDivision durch zwei ist nur eine Verschiebung. Sie können auch verwenden '0' + n%2, um ein ASCII / UTF-8 0 oder 1 zu erhalten. Dies '1'ist das nächste ASCII-Zeichen danach '0'. Sie können also einfach hinzufügen, anstatt ein zu verwenden ?:. Sie können auch eine Schleife char buf[sizeof(n)]ausführen, anstatt ein Zeichen einzeln an eine Zeichenfolge anzuhängen.
Peter Cordes
4

Hier sind zwei Ansätze. Der eine ähnelt Ihrem Ansatz

#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 der andere verwendet std :: bitset, wie andere vorgeschlagen haben.

#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;
    }
}
Vlad aus Moskau
quelle
4

Eine intVariable ist nicht dezimal, sondern binär. Was Sie suchen, ist eine binäre Zeichenfolgendarstellung der Zahl, die Sie erhalten können, 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();
Alex
quelle
3

Die Konvertierung von einer natürlichen Zahl in eine Binärzeichenfolge:

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";
}
Kiril Ilarionov
quelle
2

Hier ist eine moderne Variante, die für intsverschiedene 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();
}
Jan Christoph Uhde
quelle
0

Sie möchten etwas tun wie:

cout << "Enter a decimal number: ";
cin >> a1;
cout << setbase(2);
cout << a1
JoeNahmias
quelle
4
Die zulässigen Werte für setbasesind 16, 8und 10. Jeder andere Wert setzt das Basisfeld auf Null zurück (Dezimalausgabe und präfixabhängige Ausgabe). Siehe diese Referenz für weitere Details: std :: setbase - cpprefernce.com
CPlusPlus OOA und D
0

DEZIMAL BINÄR KEINE VERWENDETEN ARRAYS * von Oya:

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

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;
    }
João
quelle
Was Sie tun sollten, ist eine Schleife über eine char buffer[32]Einstellung buffer[i] = '0' + (tmp&1), um ein '0'oder '1'(ASCII / UTF-8-Zeichen) entsprechend dem niedrigen Bit von zu speichern tmp. Dann tmp >>= 1nach rechts verschieben. Die Verwendung von Gleitkommazahlen powist einfach verrückt, insbesondere für Zweierpotenzen.
Peter Cordes
0

hier ein einfacher Konverter std::stringals 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';
}
STERBLICH
quelle
0

Dies ist ein einfacheres 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; 
}
Sonani Meet
quelle
0

Es gibt in der Tat einen sehr einfachen Weg, dies zu tun. Wir verwenden eine rekursive Funktion, die im Parameter die Nummer (int) erhält. 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;
}
Sahil Shah
quelle
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;
}
ניתאי דרעי
quelle
0
#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;
    }
}
Harutyun Khachatryan
quelle
3
Erklären Sie, warum Ihr Code die Frage beantwortet.
Tom Aranda
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;
    }
A. siddiqui
quelle
0
std::string bin(uint_fast8_t i){return !i?"0":i==1?"1":bin(i/2)+(i%2?'1':'0');}
qlp
quelle
@ Rabbid76 Der Fragesteller sucht nach einem "einfacheren Weg", eine "Dezimalzahl in eine Binärzahl" umzuwandeln, weil sein ursprüngliches Programm so lang war, dass er das Gefühl hatte, "dass es einen viel einfacheren Weg gibt", das Problem zu lösen. Er fragt: "Kannst du es mir zeigen?" Später bearbeitete er seine Frage "Hier ist die Lösung, die ich letztendlich verwendet habe". Meine Antwort, die lediglich eine Variation seiner Lösung ist, bietet eine einfachere Möglichkeit, eine Dezimalstelle in eine Binärzahl umzuwandeln. Ich bin jetzt sehr neugierig, Ihre Interpretation der Frage zu verstehen, da Ihre Empfehlung etwas unangemessen ist, da der Fragesteller seit fast 3 Jahren inaktiv ist.
qlp
0
// 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];
}

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

oder mit 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;
    }


}
mjp
quelle
0

In C ++ können Sie hierfür die Funktion itoa () 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

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

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

Hier ist meine Sicht auf diese 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 überprüfen.

@bit_precision = Das am weitesten links stehende Bit, nach dem gesucht werden muss.

@Length = Die maximale Byteblockgröße. ZB 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 von uns eingestellte Zeichenfeld aufzurufen. Wir setzen dies auf statisch, damit es nicht bei jedem Aufruf neu erstellt wird. Um einfach ein Ergebnis zu erhalten und es anzuzeigen, funktioniert dies gut. Wenn Sie jedoch mehrere Ergebnisse auf einer Benutzeroberfläche anzeigen möchten, werden alle als letztes Ergebnis angezeigt. Dies kann durch Entfernen der statischen Aufladung behoben werden. 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 darüber hinaus wird ignoriert. Oder wie in der 2. Schleife gezeigt auf 0 gesetzt.

@first loop - Hier setzen wir den Wert auf 48 und addieren im Grunde eine 0 oder 1 zu 48 basierend auf dem Bool-Wert von (value & bit_value) == bit_value. Wenn dies wahr ist, wird das Zeichen auf 49 gesetzt. Wenn dies falsch ist, wird das Zeichen auf 48 gesetzt. Dann verschieben wir den 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 BEISPIELE !!!

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.

GESCHWINDIGKEITSTESTS

Antwort der ursprünglichen Frage: "Methode: toBinary (int);"

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

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

// 64-Bit-Präzision verwenden.

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

// 1 Bit Präzision verwenden.

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

Jeremy Trifilo
quelle
0
#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 ein einfacher Weg, um die binäre Form eines Int zu erhalten. Gutschrift an learncpp.com. Ich bin mir sicher, dass dies auf verschiedene Arten verwendet werden kann, um zum gleichen Punkt zu gelangen.

dkpaintball8488
quelle
0

Bei diesem Ansatz wird die Dezimalstelle in die jeweilige 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;
  }
};
Ganesh MS
quelle
0

Meine Art, Dezimal in C ++ in Binär umzuwandeln. Da wir aber mod verwenden, funktioniert diese Funktion auch bei hexadezimal oder oktal. Sie können auch Bits angeben. Diese Funktion berechnet weiterhin 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
Md. Touhidur Rahman
quelle
0

Ihre Lösung muss geändert werden. Die letzte Zeichenfolge sollte vor der Rückkehr umgekehrt werden:

std::reverse(r.begin(), r.end());
return r;
Omid
quelle
0

mit Bitmaske und bitweise und.

string int2bin(int n){
    string x;
    for(int i=0;i<32;i++){
        if(n&1) {x+='1';}
        else {x+='0';}
        n>>=1;
    }
    reverse(x.begin(),x.end());
    return x;
}
ABHISHEK PARMAR
quelle
0

Unten finden Sie einen einfachen C-Code, der Binär in Dezimal und wieder zurück konvertiert. Ich habe es vor langer Zeit für ein Projekt geschrieben, bei dem das Ziel ein eingebetteter Prozessor war und die Entwicklungstools eine stdlib hatten, die für das Firmware-ROM viel zu groß war.

Dies ist generischer C-Code, der keine Bibliothek verwendet, weder die Division noch den Restoperator (%) (der bei einigen eingebetteten Prozessoren langsam ist), noch Gleitkomma verwendet, noch eine Tabellensuche verwendet emulieren Sie jede BCD-Arithmetik. Es wird der Typ verwendet long long, genauer gesagt unsigned long long(oder uint64_t). Wenn Ihr eingebetteter Prozessor (und der dazugehörige C-Compiler) keine 64-Bit-Ganzzahlarithmetik ausführen kann, ist dieser Code nicht für Ihre Anwendung geeignet. Ansonsten denke ich, dass dies C-Code in Produktionsqualität ist (möglicherweise nach dem Wechsel longzu int32_tund unsigned long longzuuint64_t ). Ich habe dies über Nacht ausgeführt, um es für alle 2³² vorzeichenbehafteten 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 ohne stdlib (was ein Schwein war) tun konnten . Also nein printf()noch scanf(). Nicht einmal ein sprintf()noch sscanf(). Aber wir hatten immer noch eine Benutzeroberfläche und mussten Basis-10-Zahlen in Binärzahlen und zurück konvertieren. (Wir haben auch unser eigenes malloc()Dienstprogramm und unsere eigenen transzendentalen mathematischen Funktionen zusammengestellt.)

So habe ich es gemacht (das mainProgramm und die Aufrufe von stdlib waren da, um dieses Ding auf meinem Mac zu testen, nicht für den eingebetteten Code). Da einige ältere Entwicklungssysteme " int64_t" und " uint64_t" und ähnliche Typen nicht erkennen , werden die Typen long longund unsigned long longverwendet und als dieselben angenommen. Und longwird mit 32 Bit angenommen. Ich denke, ich hätte es typedefbearbeiten 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
Robert Bristow-Johnson
quelle
-2
#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;
}
jash.liao
quelle
3
Sie müssen etwas mehr erklären, wenn Sie möchten, dass Ihre Antwort der Community zugute kommt. Außerdem haben Sie in einer unbekannten Sprache kommentiert. Bitte bearbeiten.
J. Chomel