Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
27.04.2006, 17:54 Uhr
~haase
Gast

Um die Binärdarstellung eines 32-Bit Integers (radix 2) in der C++ Entwicklungsumgebung
zu sehen, mußte ich immer einen (T-)Rechner benutzen, was zeitraubend und lästig war.
Habe mir dann ein Makro geschrieben, um für den Compiler zusätzlich zu dezimal, hexadezimal und oktal auch die binäre Zahlendarstellung lesbar zu machen.

C++:

#define binary binaer_Darstellung_mit_fuehrender_Null_max_22_Bit
#define binaer_Darstellung_mit_fuehrender_Null_max_22_Bit(bi) ( bi % 8 ? 1 : 0 )\
                  + ( bi/8 % 8 ? 2 : 0 ) \
                  + ( bi/64 % 8 ? 4 : 0 ) \
                  + ( bi/512 % 8 ? 8 : 0 ) \
                  + ( bi/4096 % 8 ? 16 : 0 )\
                  + ( bi/32768 % 8 ? 32 : 0 )\
                  + ( bi/262144 % 8 ? 64 : 0 )\
                  + ( bi/2097152 % 8 ? 128 : 0 )\
                  + ( bi/16777216 % 8 ? 256 : 0 )\
                  + ( bi/134217728 % 8 ? 512 : 0 )\
                  + ( bi/1073741824 % 8 ? 1024 : 0 )\
                  + ( bi/8589934592 % 8 ? 2048 : 0 )\
                  + ( bi/68719476736 % 8 ? 4096 : 0 )\
                  + ( bi/549755813888 % 8 ? 8192 : 0 )\
                  + ( bi/4398046511104 % 8 ? 16384 : 0 )\
                  + ( bi/35184372088832 % 8 ? 32768 : 0 )\
                  + ( bi/281474976710656 % 8 ? 65536 : 0 )\
                  + ( bi/2251799813685248 % 8 ? 131072 : 0 )\
                  + ( bi/18014398509481984 % 8 ? 262144 : 0 )\
                  + ( bi/144115188075855872 % 8 ? 524288 : 0 )\
                  + ( bi/1152921504606846976 % 8 ? 1048576 : 0 )\
                  + ( bi/9223372036854775808 % 8 ? 2097152 : 0 )

                  // + ( bi/73786976294838206464 % 8 ? 4194304 : 0 )
                  // größere Zahlen läßt sich der Compiler oktal nicht bieten

#define bin(a, b, c, d) (((binary( a )) << 24) | ((binary( b )) << 16) |\
                        ((binary( c )) << 8) | (binary( d )))
                  //Die vier Bytes eines 32 Bit Wertes lassen sich jeweils mit führender Null
                  //und durch Komma getrennt in Binärschreibweise übergeben.

Beispiel:
            short a = binary(01111101111111011);
                  a &= binary(01101111101110111);//löscht 3., 9. und 13. Bit
                  a |= binary(00000010000000000);//setzt 6.Bit

Mein Makro kann nur 22 Bits übergeben.
Hat jemand eine Idee für die 32.Bit Variante?

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
27.04.2006, 20:21 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)

wie wärs einfach mit nem string von nullen und einsen statt den Precompiler zu vergewaltigen?
--
...fleißig wie zwei Weißbrote

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
27.04.2006, 21:49 Uhr
~haase
Gast

einfach als String von nullen und einsen ? Dann müßte ich den Quelltext durch ne'n selbstgeschriebenen Präprozessor schicken, bevor der Compiler ihn zu sehen bekommt.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
27.04.2006, 22:18 Uhr
0xdeadbeef
Gott
(Operator)

Deine "22 bit" werden intern als normale Zahl behandelt, das sind 32. Nur wenn du dir die anderen Ziffern versagst, kannste da natürlich nicht so viel reinpacken.

Meiner Ansicht nach ist die sinnvollste Methode hex zu benutzen. Und ansonsten, wenn wirklich alles fehlschlägt, zwei mal 16 kombinieren:

C++:

#define bin16(x) ...
#define bin32(x, y) (bin16(x) << 16 | bin16(y))

...

int a = bin32(1000110101110101, 1111000010101010);

Bearbeitung von 0xdeadbeef:

wobei, moment mal - das ist eigentlich ein bisschen groß für 32bit-Zahlen, was da als operand übergeben wird. Vielleicht besser mit oktetts arbeiten.

--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 27.04.2006 um 22:19 Uhr von 0xdeadbeef editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

004
01.05.2006, 05:58 Uhr
Helmut

Also eine 8 Bit-Variante deines Makro reicht mir völlig aus.
Spart einem Zeit, wenn man mit Bits setzen usw. zu tun hat.
Was neu ist, man braucht jetzt keine führende Null mehr.
8 Ziffern pro Byte sind jedoch zwingend erforderlich.

C++:

#define bin8(bi) bi <= 01111111 ?\
           ((bi%8?1:0)\
           +(bi/8%8?2:0)\
           +(bi/64%8?4:0)\
           +(bi/512%8?8:0)\
           +(bi/4096%8?16:0)\
           +(bi/32768%8?32:0)\
           +(bi/262144%8?64:0))\
           :((bi%10?1:0)\
           +(bi/10%10?2:0)\
           +(bi/100%10?4:0)\
           +(bi/1000%10?8:0)\
           +(bi/10000%10?16:0)\
           +(bi/100000%10?32:0)\
           +(bi/1000000%10?64:0)\
           +(bi/10000000%10?128:0))

#define bin16(a, b) (((bin8( a )) << 8) | (bin8( b )))

#define bin32(a, b, c, d) (((bin8( a )) << 24) | ((bin8( b )) << 16) |\
                        ((bin8( c )) << 8) | (bin8( d )))

//z.B.   char c  ^= bin8(00111100);
//       short d &= bin16(10111100,00111100);
//       int e   |= bin32(10111100,10111100,10111100,10111100);

MfG Helmut

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

005
01.05.2006, 11:35 Uhr
0xdeadbeef
Gott
(Operator)

Ich bin zwar der Ansicht, dass dir mit HExadezimalzahlen eher geholfen wäre, aber das ist deine Entscheidung. Wilder Wust von Kram...

--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: