Dez. in Bin. umrechnen!

[Klaus (Gast)]

Hallo,

würde gerne Dez-Zahlen in Binär umrechnen und bin jetzt schon eine weile 
am suchen. Also ich suche eine einfache Fkt. wie eine art Typumwandlung. 
Wo kann ich so was am besten nachschlagen und gibt es da quasi eine 
Standart Bib. oder muss ich das über eine selbst geschriebene Formel 
Realisieren?

Fussnote: Selber Programmiert hab ich es schon und es geht. Dachte nur 
es gibt das schon was vorgefertiges.

Viele Grüße!

[(prx) A. K. (prx)]

Was genau verstehst du hier unter "Dezimal"? ASCII-Text? Das wäre 
beispielsweise strto[u]l.

[Peter II (Gast)]

Klaus schrieb:
> Fussnote: Selber Programmiert hab ich es schon und es geht. Dachte nur
> es gibt das schon was vorgefertiges.

dann zeige mal was du gemacht hast, denn es ist nicht ganz klar was du 
meinst.

[Klaus (Gast)]

aso, ich will von 0 bis 255 in einer for-schleife hochzählen und das 
quasi die zwischen schritte immer umrechnen. Also:

 0 = 0000 0000
 1 = 0000 0001
...

[Klaus (Gast)]

int(main)void
{
   int zahl, dezimal, rest, ergebnis=0, faktor=1;

  printf("***** DEZIMAL ==> BINAER *****");
  printf("\n\nBitte geben sie die Zahl ein, die ins binaere

        Zahlensystem konvertiert werden soll : ");
  scanf("%i", &dezimal);

  zahl=dezimal;

  while (dezimal)
    {
    rest = dezimal % 2;
    dezimal = dezimal / 2;

               faktor *= 10;
     ergebnis = ergebnis + rest * faktor;
    }

  printf ("\n\n %i als binaere Zahl : %i ", zahl, ergebnis);
       return_EXIT SUCCESS;
}

[Max H. (hartl192)]

"0000 0001" als String, interne speichert dein PC die Zahlen schon so.

[Klaus (Gast)]

ich suche quasi so etwas wie eine einfachen Prefix der aus der 255 von 
mir aus eine 1111 1111 macht. Also so was wie i = (inbin)255; .. oder so 
in der Art :D. wenns das nicht gibt nicht so wild dann mach ichs über 
die "große" Fkt.

[Max H. (hartl192)]

Wenn's nur für die Ausgabe ist könnte man die Zahl so binär in eine 
String schreiben:

  char str[20] = "";
  itoa(dezimal, str, 2);
  printf(str);

[Peter II (Gast)]

Klaus schrieb:
> ich suche quasi so etwas wie eine einfachen Prefix der aus der 255 von
> mir aus eine 1111 1111 macht.

was soll denn 1111 1111 sein? Ein string?

[Klaus (Gast)]

gibts da eine gute Seite auf der man diese Fkt. also wie itoa usw. 
nachlesen kann? das was ich bis jetzt dazu immer gefunden hab fand ich 
nicht so super :/

[Max H. (hartl192)]

http://www.cplusplus.com/reference/cstdlib/

[Klaus (Gast)]

danke!

[Nil (nilsnilss)]

Dir scheint nicht ganz klar zu sein dass sowohl eine dezimale als auch 
binäre Zahl immer noch das gleiche sind: Eine Zahl.
Binär und dezimal verändert lediglich die Darstellungsweise, nicht aber 
den Wert der Zahl.

Wie du die Zahl nun entsprechend darstellen kannst wurde ja bereits 
gezeigt.

[DirkB (Gast)]

Wie du aber siehst, gehört itoa nicht zum Standard.

Es gibt auch verschiedene Versionen davon (mit und ohne Angabe der 
Basis).

Im Standard gibt es keine Funktion dafür.

Umgekehrt kannst du strtol nehmen.
Wenn du nur deine Funktion überprüfen willst, kannst du dein Ergebnis 
mit strtol wieder zurückwandeln und dann prüfen.

[Rolf Magnus (Gast)]

Klaus schrieb:
> ich suche quasi so etwas wie eine einfachen Prefix der aus der 255 von
> mir aus eine 1111 1111 macht. Also so was wie i = (inbin)255; .. oder so
> in der Art :D. wenns das nicht gibt nicht so wild dann mach ichs über
> die "große" Fkt.

Die 255 ist erstmal eine Zahl. Intern speichert der Computer diese 
grundsätzlich immer im Dualsystem, denn was anderes kennt er dafür gar 
nicht. Also ob du jetzt

x = 12;

oder

x = 0xC;

schreibst, macht erstmal keinen Unterschied. Aus beidem macht der 
Compiler exakt den gleichen Code, und auch der in x gespeicherte Wert 
ist genau gleich, und man kann ihm nachher nicht mehr ansehen, wie es 
bei der Zuweisung angegeben war.
Erst, wenn du den Wert ausgeben willst, muss daraus ein String, also 
Text erzeugt werden, und dort kann die Darstellung dann unterschiedlich 
gemacht werden.

[mampf (Gast)]

wie wärs mit sowas ...


unsigned char s[9];

void int2bin(char* dst, int i) {
    for (int j=0;j<8;j++) {
        s[j]=(i & (7-0)) ? '1' : '0';
    }
    s[8]=0;
    return dst;
}

printf("%i -> %s", 123, int2bin(s, 123));


man schiebt einen int rein und bekommt einen nullterminierten string 
raus ...

[mampf (Gast)]

ups sollte natürlich s[j]=(i & (2<<(7-j))) ? '1' : '0'; heißen ... aber 
weiß ja bestimmt jeder, was gemeint ist ...

[Karl H. (kbuchegg)]

mampf schrieb:
> ups sollte natürlich s[j]=(i & (2<<(7-j))) ? '1' : '0';

immer noch falsch.

> heißen ... aber
> weiß ja bestimmt jeder, was gemeint ist ...

Ein Neuling weiss aber nicht, was gemeint ist.

Ganz abgesehen, dass variable Shifter nichtgewollt sind. Wenn schon dann 
so

void int2bin(char* dst, uint8_t i) {
  for (uint8_t j = 0; j < 8; j++ ) {
    dst[j] = (i & 0x80) ? '1' : '0';
    i <<= 1;
  }
  dst[8]=0;
}

int main()
{
  char str[9];

  int2bin( str, 29 );
  printf( "%s\n", str );
}

[mampf (Gast)]

Warum sind variable Shifter nicht gewollt? ;)

[Frank M. (ukw) (Moderator)]

mampf schrieb:
> Warum sind variable Shifter nicht gewollt? ;)

Weil ein AVR mangels geeigneter Hardware ("Barrel-Shifter") jeden 
einzelnen Shift in einer Schleife machen muss. Das dauert einfach - 
abgesehen vom erhöhten Flash-Verbrauch.

[Ausgeloggt (Gast)]

> Weil ein AVR mangels geeigneter Hardware ("Barrel-Shifter")
> jeden einzelnen Shift in einer Schleife machen muss. Das
> dauert einfach - abgesehen vom erhöhten Flash-Verbrauch.

uint8_t u8shiftLeft(uint8_t value, uint8_t bits)
{
  switch(bits)
  {
    case 7: value <<= 1u;
    case 6: value <<= 1u;
    case 5: value <<= 1u;
    case 4: value <<= 1u;
    case 3: value <<= 1u;
    case 2: value <<= 1u;
    case 1: value <<= 1u;
    default:
  }
  return value;
}

Schau mal, ohne Schleifen und weitgehend optimal! ;-)

[Frank M. (ukw) (Moderator)]

Ausgeloggt schrieb:
> Schau mal, ohne Schleifen und weitgehend optimal! ;-)

Wenn Du - wie Karl Heinz - eine Maske mitführst, dann muss ein Wert pro 
Schleifendurchlauf nur einmal geschoben werden - also ingesamt 8 mal.

Wenn Du für jeden Schleifendurchlauf stattdessen Deine Funktion 
aufrufst, wird - je nach Wert von "bits" - 0 bis 7 mal geschoben. Macht 
in der Summe 0+1+2+3+4+5+6+7 = 28 mal.

Was meinst Du, was effektiver ist? ;-)

[Ausgeloggt (Gast)]

Frank M. schrieb:
> Wenn Du - wie Karl Heinz - eine Maske mitführst, dann muss ein Wert
> pro Schleifendurchlauf nur einmal geschoben werden - also ingesamt
> 8 mal.

Na so was ;-) Stimmt. Habe ich in meinem Enthousiasmus übersehen.

> Was meinst Du, was effektiver ist? ;-)

Das alles liegen lassen und einfach printf("%0X", ...) benutzen.
Und wer das nicht im Kopf in binär übersetzen kann, soll es lernen! :-P