[C++] Long Zahl als Binär Zahl verarbeiten /ausgeben

[realtec]

Hallo zusammen, wie kann ich eine long Zahl als Binär Zahl ausgeben? Bzw. Anzahl der Nullen und einsen zählen u.ä.??
Danke!

[RapidMax]

Hmm, das ist ein wenig Handarbeit:


/* Binäre Darstellung der Zahl n */
std::string int32_to_bin(u_int32_t n) {
const char DIGITS[2] = { '0', '1' };
std::string str(32, '.');
str[ 0] = DIGITS[(n >> 31) & 0x00000001];
str[ 1] = DIGITS[(n >> 30) & 0x00000001];
str[ 2] = DIGITS[(n >> 29) & 0x00000001];
str[ 3] = DIGITS[(n >> 28) & 0x00000001];
str[ 4] = DIGITS[(n >> 27) & 0x00000001];
str[ 5] = DIGITS[(n >> 26) & 0x00000001];
str[ 6] = DIGITS[(n >> 25) & 0x00000001];
str[ 7] = DIGITS[(n >> 24) & 0x00000001];
str[ 8] = DIGITS[(n >> 23) & 0x00000001];
str[ 9] = DIGITS[(n >> 22) & 0x00000001];
str[10] = DIGITS[(n >> 21) & 0x00000001];
str[11] = DIGITS[(n >> 20) & 0x00000001];
str[12] = DIGITS[(n >> 19) & 0x00000001];
str[13] = DIGITS[(n >> 18) & 0x00000001];
str[14] = DIGITS[(n >> 17) & 0x00000001];
str[15] = DIGITS[(n >> 16) & 0x00000001];
str[16] = DIGITS[(n >> 15) & 0x00000001];
str[17] = DIGITS[(n >> 14) & 0x00000001];
str[18] = DIGITS[(n >> 13) & 0x00000001];
str[19] = DIGITS[(n >> 12) & 0x00000001];
str[20] = DIGITS[(n >> 11) & 0x00000001];
str[21] = DIGITS[(n >> 10) & 0x00000001];
str[22] = DIGITS[(n >> 9) & 0x00000001];
str[23] = DIGITS[(n >> 8) & 0x00000001];
str[24] = DIGITS[(n >> 7) & 0x00000001];
str[25] = DIGITS[(n >> 6) & 0x00000001];
str[26] = DIGITS[(n >> 5) & 0x00000001];
str[27] = DIGITS[(n >> 4) & 0x00000001];
str[28] = DIGITS[(n >> 3) & 0x00000001];
str[29] = DIGITS[(n >> 2) & 0x00000001];
str[30] = DIGITS[(n >> 1) & 0x00000001];
str[31] = DIGITS[(n >> 0) & 0x00000001];
return str;
}


Wer gerne nicht so viel schreibt, und trotzdem auf eine Schlaufe verzichten will (Naja, eine Schlaufe würde der Compiler unrollen, ist schlussendlich das gleiche...) kann eine kleine Lookup-Tabelle nutzen:


/* weitere Variante zum Umwandeln in die binäre Darstellung */
std::string int32_to_bin2(u_int32_t n) {
const char *DIGITS[16] =
{ "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" };
std::string str;
str = DIGITS[(n >> 28) & 0x0000000F];
str += DIGITS[(n >> 24) & 0x0000000F];
str += DIGITS[(n >> 20) & 0x0000000F];
str += DIGITS[(n >> 16) & 0x0000000F];
str += DIGITS[(n >> 12) & 0x0000000F];
str += DIGITS[(n >> 8) & 0x0000000F];
str += DIGITS[(n >> 4) & 0x0000000F];
str += DIGITS[(n >> 0) & 0x0000000F];
return str;
}


Zum zählen der Nullen und einsen kann auch entweder viel Handarbeit, eine Schlaufe oder die gleiche Technik wie oben mit der Lookup-Tabelle verwendet werden:


/* Zählt alle einer der Zahl n */
int ones_int32(u_int32_t n) {
const char NUM[16] = { 0, 1, 1, 2, 1, 2, 2, 3,
1, 2, 2, 3, 2, 3, 3, 4 };
return NUM[(n >> 0) & 0x0000000F]
+ NUM[(n >> 4) & 0x0000000F]
+ NUM[(n >> 8) & 0x0000000F]
+ NUM[(n >> 12) & 0x0000000F]
+ NUM[(n >> 16) & 0x0000000F]
+ NUM[(n >> 20) & 0x0000000F]
+ NUM[(n >> 24) & 0x0000000F]
+ NUM[(n >> 28) & 0x0000000F];
}


Zum Testen noch das Grundgerüst:


#include <string>
#include <iostream>
#include <sys/types.h>

int main() {
std::cout << "0xA500F055 : " << int32_to_bin(0xA500F055) << "b" << std::endl;
std::cout << "0xA500F055 : " << int32_to_bin2(0xA500F055) << "b" << std::endl;
std::cout << "Einer: " << ones_int32(0xA500F055) << std::endl;
std::cout << "Nullen: " << (32 - ones_int32(0xA500F055)) << std::endl;
return EXIT_SUCCESS;
}


So, das Ganze auf 8, 16 und 64 Bit zu übertragen, bzw. zu verallgemeinern, sei dem geneigten Leser überlassen ...

Gruss, Andy

[realtec]

Nachdem ich nun den ganzen Mittag dran gebastelt habe, will ich es auch weitergeben...
Es geht nämlich auch einfacher:



#include <iostream>
using namespace std;

int main()
{
const int BYTELAENGE = 8;
unsigned long maske = 0x1 << (BYTELAENGE * sizeof(long) -1);
unsigned long hilf;
long eingabe;

cout << "Bitte geben Sie eine long-Zahl ein: ";
cin >> eingabe;

hilf = eingabe;
for(int i = 1; i <=BYTELAENGE * sizeof(long); i++)
{
if((hilf & maske) == 0)
cout << '0';
else
cout << '1';
maske >>=1;
}
cout << '.' << endl;
}