Variable durch Bitoperatoren überschreiben



  • 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. 🙂 🙂


Anmelden zum Antworten