Umwandlung von binären in C++

Ich habe eine Funktion, die konvertiert zahlen in eine Binärzahl um. Aus irgendeinem Grund funktioniert es nicht. Es gibt den falschen Ausgang. Die Ausgabe erfolgt im binären format, aber es gibt immer das falsche Ergebnis für binäre zahlen, die mit null enden(zumindest das was ich mitbekommen..)

unsigned long long to_binary(unsigned long long x)
{
    int rem;
    unsigned long long converted = 0;

    while (x > 1)
    {
        rem = x % 2;
        x /= 2;
        converted += rem;
        converted *= 10;
    }

    converted += x;

    return converted;
}

Bitte helfen Sie mir es zu beheben, das ist wirklich frustrierend..

Dank!

Es ist wirklich frustrierend, denn die zahlen sind bereits in binärer form, und es gibt keine Notwendigkeit, zu konvertieren. Was Sie tun können, ist, zum ausgeben der bits, aber es gibt massig Beispiele im Internet.
Was Sie tun, ist die Umwandlung in eine Dezimalzahl, das aussieht wie binäre, hat aber den falschen Wert. Was genau ist Ihre Hausaufgabe?
Ist dieses Hausaufgaben?
Es ist keine Hausaufgabe. Ich versuche, hier etwas lernen. Ich weiß, zahlen sind bereits binären, aber Sie werden angezeigt als Dezimalzahl. Ich möchte nur die Anzeige als Binär, und das zu tun, muss ich konvertieren Sie die dezimale Darstellung binäre. Oder mache ich das? Wenn es einen Weg gibt, um anzuzeigen, wie Sie Ihre binäre Darstellung, ich möchte wirklich, um es zu sehen. Dank
möglich, Duplikat der Wie konvertieren eines int in eine binäre Zahl in einen string in C++

InformationsquelleAutor Lockhead | 2011-02-28

binary c++decimal

2
1. Sie sind die Umkehrung der bits.
2. Sie können die Reste x als Indikator, wenn zum beenden der Schleife.
Berücksichtigen, z.B. 4.

Nach dem ersten loop iteration:
```
rem == 0
converted == 0
x == 2
```
Nach dem zweiten loop iteration:
```
rem == 0
converted == 0
x == 1
```
Und wird dann umgewandelt zu 1.

Versuchen:
```
int i = sizeof(x) * 8; //i is now number of bits in x
while (i>0) {
  --i;
  converted *= 10;
  converted |= (x >> i) & 1;
  //Shift x right to get bit number i in the rightmost position, 
  //then and with 1 to remove any bits left of bit number i,
  //and finally or it into the rightmost position in converted
}
```
Mit den obigen code mit x als unsigned char (8 bits) mit dem Wert 129 (Binär 10000001)

Beginnend mit i = 8 Größe von unsigned char * 8. In der ersten Schleife iteration i 7 sein wird. Dann nehmen wir x (129) und Verlagerung von it-rechten 7 bits, und gibt den Wert 1 ein. Dies ist mit ODER verknüpft, in converted die wird 1. Nächste iteration starten wir durch Multiplikation converted mit 10 (so, jetzt ist es 10), die wir dann shift x 6 bits right (Wert, 2) und Endet mit 1 " (Wert wird zu 0). Wir ODER 0 mit converted werden, was dann immer noch 10. 3.-7. iteration das gleiche tun, ist converted wird multipliziert mit 10, und ein bestimmtes bit aus dem es gewonnen wird x und mit ODER verknüpft, in converted. Nach diesen Iterationen converted 1000000.

In der letzten iteration, erste converted wird multipliziert mit 10 und wird zu 10000000, verschieben wir x rechts 0-bits, woraus sich der ursprüngliche Wert 129. Wir UND x durch 1, ergibt dies den Wert 1. 1 ist dann mit ODER verknüpft, in converted, die wird 10000001.
- Er ist nicht mit der bleibt einem stop-Zustand, und ich denke, dein Stück code, das eine Erklärung brauchen. Ich verstehe es, aber ich bezweifle, dass jemand mit grundlegenden C-Kenntnissen würde. Und Ihnen fehlt die Initialisierung konvertiert, das ist ganz wichtig.
- Erklären Sie die Letzte Zeile? Für welchen Zweck hast du Bitweises ODER, UND und rechts? Und auch, was ist der Zweck der ersten Zeile(sizeof(x) * 8)?
- Bearbeitet mit mehr details
- Immer noch ein bisschen Schwierigkeiten zu verstehen, dieser... Verzeihen Sie meine Unwissenheit 😛 Könntest du vielleicht ein Beispiel zeigen wie das funktioniert?
- Genial! Danke! Ich verstehe es jetzt! Ich profiliert mit gprof und dies scheint die beste Methode.
InformationsquelleAutor Erik

Verwendung von std::bitset zu tun, die übersetzung:

#include <iostream>
#include <bitset>
#include <limits.h>

int main()
{
    int     val;
    std::cin >> val;

    std::bitset<sizeof(int) * CHAR_BIT>    bits(val);
    std::cout << bits << "\n";

}

InformationsquelleAutor Martin York

1

Du machst es falsch 😉

http://www.bellaonline.com/articles/art31011.asp

Bleibt von der ersten division ist das bit ganz rechts in der binären form, mit der Funktion wird das bit ganz Links.

Können Sie etwas wie das hier tun :
```
unsigned long long to_binary(unsigned long long x)
{
    int rem;
    unsigned long long converted = 0;
    unsigned long long multiplicator = 1;

    while (x > 0)
    {
        rem = x % 2;
        x /= 2;
        converted += rem * multiplicator;
        multiplicator *= 10;
    }

    return converted;
}
```
edit: der code vorgeschlagen von CygnusX1 ist ein wenig effizienter, aber weniger umfassend, ich denke, ich werde beraten, wobei seine version.

Verbesserung : ich habe die stop-Bedingung der while-Schleife, so wir die Zeile entfernen kann, hinzufügen von x am Ende.
- +1 nur für die "Du machst es falsch ;)"
InformationsquelleAutor krtek
0

Sind Sie eigentlich die Umkehrung der binären Zahl!
to_binary(2) wieder die 01 statt 10. Beim ersten 0es werden abgeschnitten, es wird gleich Aussehen wie die 1.

wie es zu tun auf diese Weise:
```
unsigned long long digit = 1;
while (x>0) {
  if (x%2)
    converted+=digit;
  x/=2;
  digit*=10;
}
```
InformationsquelleAutor CygnusX1
0

Was ist mit std::bitset?

http://www.cplusplus.com/reference/stl/bitset/to_string/

InformationsquelleAutor Kevin

Wenn Sie anzeigen wollen Sie die Zahl als Binär -, müssen Sie zu formatieren und Sie als string. Der einfachste Weg, dies zu tun, die ich kenne, ist die Verwendung der STL bitset.

#include <bitset>
#include <iostream>
#include <sstream>

typedef std::bitset<64> bitset64;


std::string to_binary(const unsigned long long int& n)
{
        const static int mask = 0xffffffff;
        int upper = (n >> 32) & mask;
        int lower = n & mask;
        bitset64 upper_bs(upper);
        bitset64 lower_bs(lower);
        bitset64 result = (upper_bs << 32) | lower_bs;
        std::stringstream ss;
        ss << result;
        return ss.str();
};

int main()
{
        for(int i = 0; i < 10; ++i)
        {
                std::cout << i << ": " << to_binary(i) << "\n";
        };
        return 1;
};

Die Ausgabe dieses Programms ist:

0: 0000000000000000000000000000000000000000000000000000000000000000
1: 0000000000000000000000000000000000000000000000000000000000000001
2: 0000000000000000000000000000000000000000000000000000000000000010
3: 0000000000000000000000000000000000000000000000000000000000000011
4: 0000000000000000000000000000000000000000000000000000000000000100
5: 0000000000000000000000000000000000000000000000000000000000000101
6: 0000000000000000000000000000000000000000000000000000000000000110
7: 0000000000000000000000000000000000000000000000000000000000000111
8: 0000000000000000000000000000000000000000000000000000000000001000
9: 0000000000000000000000000000000000000000000000000000000000001001

InformationsquelleAutor Stephan

Wenn Ihr Ziel ist nur die Anzeige, wie Sie Ihre binäre Darstellung, dann können Sie versuchen itoa oder std::bitset

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <bitset>

using namespace std;

int main()
{
    unsigned long long x = 1234567890;

    //c way
    char buffer[sizeof(x) * 8];
    itoa (x, buffer, 2);
    printf ("binary: %s\n",buffer);

    //c++ way
    cout << bitset<numeric_limits<unsigned long long>::digits>(x) << endl;

    return EXIT_SUCCESS;
}

itoa ist ein nicht-standard-Funktion, die nicht verfügbar ist auf vielen Plattformen (ich habe nur gesehen das auf windows).

InformationsquelleAutor Oleg Svechkarenko

void To(long long num,char *buff,int base)
{
    if(buff==NULL)      return;
    long long m=0,no=num,i=1;

    while((no/=base)>0) i++;
    buff[i]='\0';

    no=num;
    while(no>0)
    {
        m=no%base;
        no=no/base;
        buff[--i]=(m>9)?((base==16)?('A' + m - 10):m):m+48;
    }
}

InformationsquelleAutor madan

Hier ist eine einfache Lösung.

#include <iostream>
using namespace std;
int main()
{
    int num=241; //Assuming 16 bit integer
    for(int i=15; i>=0; i--) cout<<((num >> i) & 1);
    cout<<endl;
    for(int i=0; i<16; i++) cout<<((num >> i) & 1);
    cout<<endl;
    return 0;
}

InformationsquelleAutor Ambrish

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.