Umwandlung in Binärzahlen

Computer: Software & Programmierung C/C++
#1

Hallo,

für ein Programm muss ich mehrere Zeichen in ihrer dezimalen, hexadezimalen und binären Darstellung verarbeiten, also z.B.
‚A‘ = 65 = 1000001 = 0x41.

Umwandeln von char nach int macht C/C++ ja mittels casting von alleine, aber wie kann ich die anderen beiden Darstellungen realisieren? Gibt es dafür schon fertige Funktionen oder muss ich etwa den kompletten „Wandle die int-Zahl nach binär“-Algorithmus per Hand implementieren (dto. hex)?

Weiterhin muss ich dann auf jedes einzelne Bit zugreifen können, da ich sie verschieben und löschen muss.

Vielleicht hat da jemand ein paar Tips?

Viele Grüße, Robert

#2

Hallo Robert,

die Aufgabe stellte sich mir im Rahmen meines Studium auch schon einmal. Seinerzeit verwendete ich untige Funktion um das Problem zu lsen. Die Krte die man schlucken musz ist halt, dasz die Binaerzahl aufgrund der Begrenzung von Long auch begrenzt ist. Die zweite Funktion hab ich eben im Usenet gefunden. Diese macht halt selbst gleich die Ausgabe (ich wei nicht, ob Du das willst) alternativ knnte man die Werte auch in einen int arry einspeisen.

Ok, hoffe weitergeholfen zu haben…
micha

unsigned long dezimal\_zu\_binaer(unsigned int dezimal)
{
 unsigned long zaehler\_binaer = 1,binaer = 0;
 int zaehler\_dezimal = 1;

 while((int)(dezimal - zaehler\_dezimal) \> 0)
 {
 zaehler\_dezimal = zaehler\_dezimal \* 2;
 zaehler\_binaer = zaehler\_binaer \* 10;
 }
 while(zaehler\_binaer \> 0)
 {
 if ((int)(dezimal - zaehler\_dezimal) \>= 0)
 {
 binaer += zaehler\_binaer;
 dezimal -= zaehler\_dezimal;
 }
 zaehler\_binaer = zaehler\_binaer / 10;
 zaehler\_dezimal = zaehler\_dezimal / 2;
 }
 return binaer;
}

Usenet:
void write\_binary(int i)
{
 if (i!=0) {
 write\_binary(i/2);
 if ((i % 2) == 0) {
 putchar('0');
 }
 else {
 putchar('1');
 }
 }
 else {
 return;
 }
}
#3

Hi,

die Umwandlung einer Dezimalzahl in eine Binärzahl gestaltet sich eigentlich ganz einfach.
Dazu benötigt man lediglich den Modulo und die Division durch 2.

Beispiel:
150(10) nach xxxxxxx(2)?
=>
150 / 2 = 75 Rest 0
75 / 2 = 37 Rest 1
37 / 2 = 18 Rest 1
18 / 2 = 9 Rest 0
9 / 2 = 4 Rest 1
4 / 2 = 2 Rest 0
2 / 2 = 1 Rest 0
1 / 2 = 0 Rest 1

Es entsteht also folgende Binärzahl (von unten nach oben!):
10010110
Test (von rechts nach links):
0*1 + 1*2 + 1*4 + 0*8 + 1*16 + 0*32 + 0*64 + 1*128 = 150

Abbruchkriterium ist also div/2 == 0 und der Rest gibt dir die nötige Binärstelle. Müsste eigentlich schnell programmiert sein.

Von Binär nach Hex kannst du dann auch auf eine einfache Regel zurückgreifen:
10010110 von oben lässt sich einfach so schreiben:
1001 0110
Dabei repräsentiert jedes Quadrupel (4Bit) eine Stelle der HexZahl.

Also:
1001 => 1*8 + 0*4 + 0*2 + 1*1 = 9
0110 => 0*8 + 1*4 + 1*2 + 0*1 = 6

=> 150(10) = 10010110(2) = 96(16)

Ist doch ganz einfach. Du brauchst also nur eine entsprechende switch-Anweisung schreiben, die dann anstatt dem Wert 10 ein A draus macht.

Hilft dir das weiter?

Ciao, Bill

#4

Hallo Robert

für ein Programm muss ich mehrere Zeichen in ihrer dezimalen,
hexadezimalen und binären Darstellung verarbeiten, also z.B.
‚A‘ = 65 = 1000001 = 0x41.

Umwandeln von char nach int macht C/C++ ja mittels casting von
alleine, aber wie kann ich die anderen beiden Darstellungen
realisieren? Gibt es dafür schon fertige Funktionen oder muss
ich etwa den kompletten „Wandle die int-Zahl nach
binär“-Algorithmus per Hand implementieren (dto. hex)?

Weiterhin muss ich dann auf jedes einzelne Bit zugreifen
können, da ich sie verschieben und löschen muss.

;Vielleicht hat da jemand ein paar Tips?

HEX geht problemlos mit printf() oder sprintf(), bei manchen Compilern ist auch eine Binärausgabe möglich.
printf(„Hex: %X\n“, a);

selber programmiert:

#define BITS 16 /\* für 16-bit integers \*/

char \*int2bin(unsigned int a)
{
 static char s[BITS+1];
 int i;

 for( i = BITS-1; i \>= 0; --i )
 {
 s[i] = ( (a & 0x1) == 0) ? '0' : '1';
 a \>\>= 1;
 }
 s[BITS] = '\0'; /\* ende string \*/
 return s;
}

/\* Diese Berechnung für NIBBLE stellt sicher, dass das \*/
/\* Ganze auch mit Bit-Zahlen, welche nicht durch 4 \*/
/\* Restlos teilbar sind funktioniert \*/
#define NIBBLE ((BITS+3) / 4)

char \*int2hex(unsigned int a)
{
 static char s[NIBBLE+1];
 int i;
 int c;

 for( i = NIBBLE-1; i \>= 0; --i)
 {
 /\* 4 Bit in ASCII wandeln \*/
 c = (a & 0x0F) + '0';

 /\* wenn c \> '9' -\> 'A' ... 'F' \*/
 if ( c \> '9' ) c += 'A'-'9'; 
 s[i] = (char) c;
 a \>\>= 4; 
 }
 s[BITS] = '\0'; /\* ende string \*/
 return s;
}

Hab’s jetz nicht mit dem Compiler getestet, sollte aber so funktionieren.

MfG Peter(TOO)

#5

OOPS
Hallo Robert

da hat sich ein Fehler eingeschlichen:

char *int2hex(unsigned int a)
{
static char s[NIBBLE+1];
int i;
int c;

for( i = NIBBLE-1; i >= 0; --i)
{
/* 4 Bit in ASCII wandeln */
c = (a & 0x0F) + ‚0‘;

/* wenn c > ‚9‘ -> ‚A‘ … ‚F‘ */
if ( c > ‚9‘ ) c += ‚A‘-‚9‘;

Hier feht was !!!
if ( c > ‚9‘ ) c += ‚A‘-‚9‘ -1 ;

s[i] = (char) c;
a >>= 4;
}
s[BITS] = ‚\0‘; /* ende string */
return s;
}

MfG Peter(TOO)

#6

wie waer’s mit der itoa function?

char *_itoa( int value, char *string, int radix );
radix ware also fuer binary 2 fuer hexadec. 16
ZB. um 256 umzuwandeln:

char* res;

itoa (256, res, 2); oder eben itoa (256, res, 16);

Das ist total simple und man braucht nicht seinen eigenen alg. zur Umwandlung in binary schreiben.

Claudia