hex -> dez oder binär in C

[Carolin Z. (seobalis)]

Hallo Leute,

wie kann ich (zB. 0x3a4b - 32bit) in Dezimal oder binär in C 
konvertieren?

Danke für euere Hilfe

Grüße
Carolin

[Google (Gast)]

Aber du kennst google?

[Carolin Z. (seobalis)]

ja das kenne ich. Aber ich kann die Lösung nicht finden

[gast (Gast)]

So könnte die Frage Sinn machen:
Ein String zb "0x3a4b" in Strings "b11101001001011" bzw "d14923" 
umwandeln(?).

Das klingt dann aber nach Hausaufgaben ;)

[Carolin Z. (seobalis)]

ich weiß wie man von Dezimal zum binär umwandel kann. Aber beim hexa bin 
ich mir nicht sicher wie ich mit dem A B C D E machen soll

[Stefanie B. (sbs)]

Dann stell doch mal deine Löung vor ;-)

Gruss
Stefan

[Carolin Z. (seobalis)]

hier ist die Lösung(von Dez zum binär)

______________________
int dez = 20;
char binar[32];
int pos;
for(pos=0;pos<32;pos++){
  while(dez !=0){
     binar[32-pos] = '0' + dez%2;
     dez = dez/2
     pos ++;
   }
}

_______________________

[Karl H. (kbuchegg)]

int hex = 0x234;
char binar[32];
int pos;
for(pos=0;pos<32;pos++){
  while(hex !=0){
     binar[32-pos] = '0' + hex%2;
     hex = hex/2
     pos ++;
   }
}

Wenn deine Zahl sowieso schon als integer vorliegt, dann
geht das genau gleich. In einem int ist eine Zahl gespeichert.
Diese Zahl ist erstmal nicht dezimal oder hexadezimal oder
binär, sondern einfach nur eine Zahl.
Und dein Programm kann von einer Zahl die binäre Repräsentierung
ermitteln.

Also weist du deiner Variablen ganz einfach die Hex Zahl zu.
Damit ist sie als Zahl in der int Variablen gespeichert und
alles andere bleibt gleich.

[Carolin Z. (seobalis)]

ah ok, danke. ich habe gedacht dass ich etwas für A B C D E F 
deklarieren muss.

[Carolin Z. (seobalis)]

int hex = 0x234;
char binar[32];
int pos;
for(pos=0;pos<32;pos++){
binar[pos] = 0;
pos = 0;
}
  while(hex !=0){
     binar[32-pos] = '0' + hex%2;
     hex = hex/2
     pos ++;
   }

[Walter (Gast)]

deine erste Schleife läuft ewig!

in der zweiten gibt es eine Bereichsüberschreitung im String!

[Carolin Z. (seobalis)]

Ups!
Sorry. ich meine so

int hex = 0x234;
char binar[32];
int pos;
for(pos=0;pos<32;pos++){
binar[pos] = 0;
}
pos =0;
  while(hex !=0){
     binar[32-pos] = '0' + hex%2;
     hex = hex/2
     pos ++;
   }

[Karl H. (kbuchegg)]

Walter wrote:
> deine erste Schleife läuft ewig!

Da hat er recht.
Mit einer besseren Codestrukturierung (Leerzeichen, konsistente
Einrückung) könnte man das auch als Anfänger sehen.

>
> in der zweiten gibt es eine Bereichsüberschreitung im String!

Auch da hat er recht (und Asche auf mein Haupt, dass ich das
einfach übernommen habe).

Array-Indizierung beginnt in C bei 0.
Bei der Definition eines Arrays wird die Anzahl der Array
Elemente angegeben. Ein Array

int tmp[4];

besteht also aus 4 Elementen. Diese sind
tmp[0], tmp[1], tmp[2], tmp[3]
Zähl sie nach: sind genau 4 Stück.
Der höchste zulässige Arrayindex in einem Array ist daher immer
um 1 kleiner als die Anzahl der Elemente im Array.

Wenn du daher ein Array hast:

char binar[32];

und so darauf zugreifst:

binar[32-pos] = ...

und pos den Wert 0 annehmen kann, dann greifst du auf
das Element 'binar[32]' zu. Das, so haben wir bereits
gesehen, existiert aber nicht. Bei einem 32-er Array ist
der höchste zulässige Index 31.

[Karl H. (kbuchegg)]

Carolin Zapa wrote:

> int hex = 0x234;
> char binar[32];
> int pos;
> for(pos=0;pos<32;pos++){
> binar[pos] = 0;
> }
> pos =0;
>   while(hex !=0){
>      binar[32-pos] = '0' + hex%2;
>      hex = hex/2
>      pos ++;
>    }

Du musst unterscheiden, zwischen der Zahl 0 und dem Zeichen '0'.
Das Zeichen '0' ist nicht dasselbe wie die Zahl 0.

Wenn du also hier:
 for( pos = 0; pos < 32; pos++ ) {
   binar[pos] = 0;
 }

das binar-Array mit 0-en füllst, so füllst du da keine
'0' Zeichen ein, sondern tatsächlich lauter 0-Zahlen.
'Unglücklicherweise' gibt es in C aber ein spezielles
Zeichen '\0', welches das Ende eines Strings markiert.
Und dieses Zeichen hat den Code (und damit die Zahl) 0.
Wenn du also den String binar nicht bis vornehin in
der 2-ten Schleife füllst, so bleiben da immer ein paar '\0'
übrig, die den String für alle Stringverarbeitenden Funktionen
beenden.

Als Grapfik:
Das sei dein Array, in dem du den String aufbauen möchtest

  +---+---+---+---+---+---+---+
  |   |   |   |   |   |   |   |
  +---+---+---+---+---+---+---+

Das initialisierst du in der ersten Schleife mit lauter 0

  +---+---+---+---+---+---+---+
  | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
  +---+---+---+---+---+---+---+

um dann von hinten beginnend die Binärzahl einzusetzen,
zb indem du '1', '0', '1' hineinschreibst

  +---+---+---+---+---+---+---+
  | 0 | 0 | 0 | 0 |'1'|'0'|'1'|
  +---+---+---+---+---+---+---+

Nur: Wie man deutlich sieht, beginnt der String immer noch mit 0.
Für jede String-verarbeitende Funktion ist daher der String bereits
beim ersten Zeichen zu Ende.

Selbst wenn du die Character '1', '0', '1', '0', '1', 0', '1'
ins Array schreibst:

  +---+---+---+---+---+---+---+
  |'1'|'0'|'1'|'0'|'1'|'0'|'1'|
  +---+---+---+---+---+---+---+

so ist auch das kein gültiger String, denn jetzt fehlt dir
immer noch das obligatorische 0-Zeichen am Stringende.

  +---+---+---+---+---+---+---+---+
  |'1'|'0'|'1'|'0'|'1'|'0'|'1'| 0 |
  +---+---+---+---+---+---+---+---+

Das wäre ein gültiger String.
Man beachte auch: Um einen String, der aus 7 sichtbaren Zeichen
besteht, in einem Array ablegen zu können, muss das Array aus
8 Elementen bestehen. Denn: Du brauchst ja auch noch das
abschliessende 0 Zeichen (das '\0' )

[Bobby (Gast)]

Und wer einen C-String erzeugen will,
sollte an die abschließende 0 denken.
Aber wem sag ich das...

[Carolin Z. (seobalis)]

:(
Also binar[31-pos]

[Carolin Z. (seobalis)]

Danke für die Antwort und euere Hilfe

[Karl H. (kbuchegg)]

Carolin Zapa wrote:
> :(
> Also binar[31-pos]

Jein.

Lies dir nochmal meine letzte Post durch.
Besonders den untersten Abschnitt.

[Carolin Z. (seobalis)]

Dann muss diese Lösung richtig sein.
Oder?
__________________________________
int hex = 0x234;
char binar[33];
int pos = 0;
for(pos=0;pos<32;pos++)
binar[pos] = '0';

pos =0;
  while(hex !=0){
     binar[32-pos] = '0' + hex%2;
     hex = hex/2
     pos ++;
   }

______________________________________

[Karl H. (kbuchegg)]

Carolin Zapa wrote:
> Dann muss diese Lösung richtig sein.
> Oder?
> ____________________________________
> int hex = 0x234;
> char binar[33];
> int pos = 0;
> for(pos=0;pos<32;pos++)
> binar[pos] = '0';
>
> pos =0;
>   while(hex !=0){
>      binar[32-pos] = '0' + hex%2;
>      hex = hex/2
>      pos ++;
>    }
>
> ________________________________________

Schnelle Frage:
Welchen Wert hat binar[32] ?

Wenn du nicht sicher bist, dann mal dir ein Array auf (muss
ja nicht eine Größe von 32 haben) so wie ich das oben getan
habe und spiel mit Papier und Bleistift deinen Code durch.

Wichtig: Vorher überlegen, wie das Ergebnis aussehen müsste
und hinten nach kontrollieren, wie es tatsächlich aussieht.

Immer noch: Eine vernünfitge Einrückung und vernünftige Verteilung
von Leerzeichen, kann sehr viel zur Lesbarkeit eines Codes beitragen

  int hex = 0x234;

  char binar[33];
  int pos = 0;

  // Das Ergebnis initialisieren ...
  binar[32] = '\0';
  for( pos = 0; pos < 32; pos++ )
    binar[pos] = '0';

  // ... und die Zahl zerlegen.
  // Achtung: Bei dieser Methode entstehen die einzelnen
  // Ziffern von rechts nach links. Daher ist es auch so
  // wichtig, dass das String-Array korrekt initialisiert
  // wird.
  pos = 0;
  while( hex != 0 && pos < 33 ) {
    binar[32-pos] = '0' + hex%2;
    hex = hex/2
    pos++;
  }

Was jetzt noch geändert werden sollte: Die im ganzen Code
verstreuten Konstanten 32, und 33. Die sollten symbolische
Makronamen bekommen.

  int hex = 0x234;

#define MAX_DIGITS  32

  char binar[MAX_DIGITS + 1];
  int pos = 0;

  // Das Ergebnis initialisieren ...
  binar[MAX_DIGITS] = '\0';
  for( pos = 0; pos < MAX_DIGITS; pos++ )
    binar[pos] = '0';

  // ... und die Zahl zerlegen.
  // Achtung: Bei dieser Methode entstehen die einzelnen
  // Ziffern von rechts nach links. Daher ist es auch so
  // wichtig, dass das String-Array korrekt initialisiert
  // wird.
  pos = 0;
  while( hex != 0 && pos < MAX_DIGITS + 1 ) {
    binar[MAX_DIGITS-pos] = '0' + hex%2;
    hex = hex/2
    pos++;
  }

[Carolin Z. (seobalis)]

Vielen Dank