hex -> dez oder binär in C

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

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

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

Gruss
Stefan

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 ++;
   }
}

_______________________

1

int hex = 0x234;

2

char binar[32];

3

int pos;

4

for(pos=0;pos<32;pos++){

5

  while(hex !=0){

6

     binar[32-pos] = '0' + hex%2;

7

     hex = hex/2

8

     pos ++;

9

   }

10

}

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.

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

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 ++;
   }

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 ++;
   }

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

1

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:

1

char binar[32];

und so darauf zugreifst:

1

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.

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' )

:(
Also binar[31-pos]

Danke für die Antwort und euere Hilfe

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

Jein.

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

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 ++;
   }

______________________________________

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

1

  int hex = 0x234;

2

3

  char binar[33];

4

  int pos = 0;

5

6

  // Das Ergebnis initialisieren ...

7

  binar[32] = '\0';

8

  for( pos = 0; pos < 32; pos++ )

9

    binar[pos] = '0';

10

11

  // ... und die Zahl zerlegen.

12

  // Achtung: Bei dieser Methode entstehen die einzelnen

13

  // Ziffern von rechts nach links. Daher ist es auch so

14

  // wichtig, dass das String-Array korrekt initialisiert

15

  // wird.

16

  pos = 0;

17

  while( hex != 0 && pos < 33 ) {

18

    binar[32-pos] = '0' + hex%2;

19

    hex = hex/2

20

    pos++;

21

  }

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

1

  int hex = 0x234;

2

3

#define MAX_DIGITS  32

4

5

  char binar[MAX_DIGITS + 1];

6

  int pos = 0;

7

8

  // Das Ergebnis initialisieren ...

9

  binar[MAX_DIGITS] = '\0';

10

  for( pos = 0; pos < MAX_DIGITS; pos++ )

11

    binar[pos] = '0';

12

13

  // ... und die Zahl zerlegen.

14

  // Achtung: Bei dieser Methode entstehen die einzelnen

15

  // Ziffern von rechts nach links. Daher ist es auch so

16

  // wichtig, dass das String-Array korrekt initialisiert

17

  // wird.

18

  pos = 0;

19

  while( hex != 0 && pos < MAX_DIGITS + 1 ) {

20

    binar[MAX_DIGITS-pos] = '0' + hex%2;

21

    hex = hex/2

22

    pos++;

23

  }

Vielen Dank