Variable durch Bitoperatoren überschreiben



  • Hallo zusammen 🙂
    ich habe ein Programm zum umrechnen von Dezimal- in Binärzahlen geschrieben. Das funktioniert soweit auch.
    Ich würde die Binärzahl die auf der Konsole ausgegeben wird gerne auch noch in einer Variable speichern.
    Dazu habe ich die variable binBits deklariert.
    Mein Plan ist folgender:
    Jedes Mal wenn eine 0 vorkommt wird bei binBits und pos zur nächsten Stelle geswitch, wenn eine 1 vorkommt wird die Stelle von pos und binBits verodert und dann beide geswitcht.
    So müsste er die einsen und Nullen speichern bzw. überschreiben.

    Ich bekomme aber nur Quatsch raus 😕 😞

    Kann mir jemand einen Tipp geben?

    int dezimalBinUmwandeln(int dezimalInput)
    {
    int bitMaske= (1 << 30) ;   //bitMaske = (Für die jeweliuge Rechnerarchitecktur]
    cout << "Binärdarstellung : " << endl;
    
    int binBits = 0; 
    int pos =(1 << 30);
    
    while(bitMaske>0)
       {
    
       if((dezimalInput & bitMaske) == 0)
       {
           binBits >>= 1; 
           pos >>=1;
           cout << "0";
       }
       else
       {
            binBits |= pos; 
            binBits >>= 1; 
            pos >>=1;
            cout<< "1"; 
       }
       bitMaske = bitMaske >> 1 ;  // Right Shift
       if (!(bitMaske > 0)) {cout<<""<<endl;break;}
       //cout << binBits <<endl;
       //return binBits;
    }}
    

    Edit durch Arcoth: Tags



  • Philipp2706 schrieb:

    Ich würde die Binärzahl die auf der Konsole ausgegeben wird gerne auch noch in einer Variable speichern.

    Als Integer? Willst du es nicht eher als ein string speichern?

    #include <iostream>
    #include <string>
    #include <sstream>
    #include <bitset>
    
    int main()
    {
        int value = 5649879;
        std::stringstream sstr;
        sstr << std::bitset <sizeof(unsigned int)*8> {value};
        std::string binary = sstr.str();
    }
    

    EDIT: Falls deine Methode funktioniert, einfach string anlegen und push_back.
    Ich habe es nicht überprüft (TBH).

    EDIT 2: Weil 32 Ziffern passen auch nicht in einen 64bit Integer.
    Anzahl Dezimalziffern für einen Integer mit n bit
    Z(n)=log10(2n)Z(n) = \lfloor{log_{10}(2^n)}\rfloor



  • wir dürfen bei der Aufgabe leider keine Strings benutzen 🙄
    Die Methode funktioniert, also es wird eine Binärzahl ausgegeben. Wenn ich aber die Variable in der diese Binärzahl gespeichert sein soll ausgebe, kommt nur quatsch raus 😃
    Ich muss diese Methode noch Plattformunabhängig machen. Das heißt die Länge des Integers an den jeweiligen Prozossor anpassen. Das sollte ich aber hinkriegen.
    Ich würda das mit numeric limits lösen.

    Mit dem Speichern in der Variable binBits tue ich mich nur sehr schwer. Ich glaube aber der Ansatz ist garnicht mal soo falsch.



  • Wie soll binBits denn aussehen?
    010100101.... ?

    Ich möchte auch darauf hinweisen, dass eine Zahl dezimal interpretiert wie binär aussieht unsinnige codierung ist.



  • Ja so hatte ich es mir mit der Zahl vorgestellt.
    Bestimmt ist das so nicht optimal und mir ist auch die Idee mit dem String gekommen aber den dürfen wir leider nicht benutzen 😞
    Es geht wohl nur darum dass wir den Umgang mit den Bitoperatoren lernen.

    Die Aufgabe lautet
    Schreiben Sie ein Programm welches eine Variable einliest und die Reihenfolge der Bits umkehrt und den enstehenden Zahlenwert in einer neuen unsigned int Variable speichert.


  • Mod

    Ich bin ziemlich sicher, dass damit nicht gemeint ist, dass du Dezimalwerte der Art 1000111010 als unsigned speichern sollst.

    Es ist ziemlich sicher so gemeint (aus Gründen der Übersichtlichkeit nehme ich mal nur 8 Bit. Wie lang ein unsigned auf deinem System ist, musst du herausfinden):
    Angenommen die Eingabe ist 67. Das ist binär b01000011. Jetzt sollst du die Bits davon umkehren, also zu b11000010, was 194 ist. Das soll das Ergebnis sein.



  • Ja ok dann wird es so sein dass man die Dezimalzahl der Binärzahl in der unsigned int speichern soll.
    Aber wie komme ich denn an die Dezimalzahl? 😕
    Die Schleife muss ja irgendwie eine Variable erzeugen. Aber ohne Strings und Arrays weiß ich da nicht weiter. Diese Zahl auf der Konsole ausgeben kann ich ja.



  • Ich muss mir sehr auf die Finger beißen nicht die Lösung reinzuhaun.

    Aber bau mal ne Schleife, die über die bits vom Eingangsinteger rübergeht und dabei die bits in der Ausgabe von der anderen Seite aus setzt, wenn sie im Eingangsinteger sind. Sollte einfach sein.



  • Da würde mir spontan sowas einfallen

    while(bitMaske>0)
    {
    dezimalInput << i-unsignedintmax = umgedrehteZahl << i;
    if (i >= unsignedintmax) return umgedrehteZahl;
    }

    Keine Ahnung ob das funktioniert 🙄


  • Mod

    Philipp2706 schrieb:

    Keine Ahnung ob das funktioniert 🙄

    So direkt noch nicht, aber du bist durchaus auf dem richtigen Weg. Jetzt mach noch die riesigen Anfängerfehler raus und du hast es fast.

    Allgemein lassen sich Fragen wie 'ob das funktioniert' natürlich beantworten, indem man es ausprobiert, und wenn es nicht funktioniert, indem man guckt, warum. Das ist eigentlich deine Aufgabe als Programmierer, und einer der besten Wege, wie man als Programmierer besser wird, anstatt zu hoffen, dass einem jemand anderes die Lösung gibt.



  • Wenns noch interessant ist, probiere mal mit

    (1 << i)
    

    zu maskieren, i ist hier die Schleifenvariable. Damit erhälst du
    0000'0001
    0000'0010
    0000'0100
    0000'1000
    0001'0000
    ...

    Ansonsten auf dem Papier vorprobieren und rechnen. Das mache ich immer sehr viel und hilft mir sehr.



  • unsigned int bitUmdrehen(unsigned int dezimalInput) {  
        unsigned int umgedrehteBits =0;
        unsigned int maxStellen = sizeof (dezimalInput)*8;
        unsigned int i = 0;
        while (i < maxStellen+1) {
            if (dezimalInput & (1 << (maxStellen - i))) (umgedrehteBits |= (1 << i));
            i++;
            if (i >= maxStellen) return umgedrehteBits;       
        }
    }
    

    Okay ich habe das ganze nocheinmal umgeschrieben. Ich bin auf jeden Fall schon einen großen Schritt weiter. Die Dezimalzahlen die ich rausbekomme sind aber noch viel zu groß.
    Ich komme an der Stelle nicht weiter. 😞

    Die andere Funktion in der ich die Dezimalzahlen in Binärzahlen umwandeln wollte, benutze ich jetzt nur noch um die Dezimalzahlen auszugeben.
    Die Bitsumdrehen Funktion erhält eine Dezimalzahl.

    5cript schrieb:

    Wenns noch interessant ist, probiere mal mit
    C++:
    (1 << i)

    zu maskieren, i ist hier die Schleifenvariable. Damit erhälst du
    0000'0001
    0000'0010
    0000'0100
    0000'1000
    0001'0000
    ...

    genau danke 👍


  • Mod

    Philipp2706 schrieb:

    Okay ich habe das ganze nocheinmal umgeschrieben. Ich bin auf jeden Fall schon einen großen Schritt weiter. Die Dezimalzahlen die ich rausbekomme sind aber noch viel zu groß.

    Was erwartest du denn und was kommt raus? Ein unsigned int bei dem die Bits weiter vorne gesetzt sind, kann schon ganz schön groß werden...



  • ich habe als Beispiel die Dezimalzahl 33 genommen. Das ist in Binärschreibweise:
    0000000000100001.
    Diese Binärzahl umgedreht (1000010000000000) ist wieder in Dezimalschreibweise 33792. Ich bekomme aber 134217729 raus. Ich kann mir das gerade nicht erklären. 😕

    Hiermit umgerechnet:http://www.arndt-bruenner.de/mathe/scripts/Zahlensysteme.htm


  • Mod

    Du gehst irrigerweise davon aus, dass ein unsigned int bei dir 16 Bit hätte. Das ist die Untergrenze, die ein unsigned int mindestens haben muss. In aller Regel wird er größer sein, auf den meisten Systemen 32 Bit. Dein Code ist bereits flexibel in dieser Hinsicht durch die Zeile 3.

    Angenommen, auf deinem System hätte ein unsigned int 32 bit, dann wären 100001 umgedreht 10000100000000000000000000000000, also 2214592512. Dein Ergebnis passt also noch nicht ganz, aber nun weißt du, woher die riesigen Zahlen kommen. Die 134217729 entsprechen 000001000000000000000000000000001, sieht so aus als hättest du das letzte Bit nicht korrekt gedreht. Vielleicht solltest du nochmal die Grenzen deiner Schleifen prüfen? 1<<32 hat 33 Binärstellen!

    Du kannst natürlich deine Stellenzahl auch fest auf 16 (oder eine beliebige andere Zahl) setzen. Solange du die oberen Bits des unsigned ints unangetastet lässt, sieht dann alles so aus als würdest du mit 16 Bits rechnen.



  • Danke 👍 👍 🙂
    ich habe es verstanden und das Programm tut auch was es soll.

    if (dezimalInput & (1 << (maxStellen - i))) (umgedrehteBits |= (1 << i-1));
    

    Ich habe einfach die -1 ergänzt. 🙂 🙂


Log in to reply