ich brauche einen Zufallsgenerator für 8-Bit Zahlen, also von 0 bis 255. Dafür wollte ich mir die Zahl dezimal generieren lassen, und dann in binär umwandeln. Bisher habe ich das immer mit itoa gemacht, aber das ist ja leider nicht ANSI-Standard.
Hat jemand von Euch eine kurze Version dafür?

Vielen Dank im Voraus, Ozzy

die Frage war eigentlich weniger die, wie man eine Zufallszahl erzeugt, sondern vielmehr, wie ich sie in eine Binärzahl umwandel. Das Auffüllen mit Nullen vorne würde ich dann auch noch schaffen, ich suche nur einfach einen Ersatz für

char buffer[256]; 
itoa(zahl,buffer,2);

MfG, Ozzy

danke für Deine schnelle Antwort. Kannst Du mir das hier vielleicht noch einmal erklären?

(for(bit=1<<8;bit;bit>>=1) ret.push_back((val&bit)?'1':'0');)

Diese Schreibweise ist mir nicht so ganz geläufig...

MfG, Ozzy

string to_bin_str(unsigned char value)
{
  string ret;
  for(unsigned char bit = 1<<7;//beginne mit 1<<7 = (1000 0000)b
      bit;                     //entspricht 'bit!=0'
      bit>>=1)                 //verschiebe Bitstelle um 1 nach rechts
    ret.push_back((value&bit)?'1':'0');
    //je nachdem, ob das aktuelle Bit in 'value' gesetzt ist, wird entweder 0 oder 1 an den String angehängt
  return ret;
}

Die Funktion klappert einfach alle Bitstellen der Eingabe von oben nach unten ab und wandelt sie jeweils in eine Binärziffer um.

ne, das ist auch nicht das, was ich suche (glaube ich).
Wenn ich mir eine int-Zahl zwischen 0 und 255 erzeugt haben lasse, möchte ich sie in eine Binärzahl umwandeln, also z.B. int 174 wird zu binär 10101110. Das geht ja mit der itoa-Funktion mit Basis 2. Es geht mir also primär nur um das umrechnen... Aber wenn möglich eben ohne so eine Funktion wie: Wenn x durch 128 > 1, dann setze msb auf 1, sonst 0...

MfG, Ozzy

Ich würde vorschlagen Du baust Dir eine Funktion ähnlich der von CStoll präsentierten und nennst sie itoa (sie muss auch nicht zwangsläufig mit std::string arbeiten). Bei ihrer Benutzung glaubst Du dann ganz fest daran dass sie ohne "Bitschieberei" auskommt

EDIT:
Alternative zur Bitschieberei wäre die Teilerei, aber das macht intern auch keinen Unterschied. Einfacher wird es vielleicht wenn Du die Länge fest auf 8 (o.ä.) begrenzt.

string result;
while ( wert > 0 ) {
   result = ( wert % 2 ? '1' : '0' ) + result;
   wert /= 2;
}

PS: Wenn es dir zu unsicher ist, diese Umwandlung von Hand zu schreiben, leg dir einen std::bitset an und verwende ihn für die Umwandlung - wie das geht, habe ich kurz in meinem Magazin-Artikel "Aufbau der STL - Teil 3" angerissen.

Ich hab das mal so gemacht:
(ausführliche Version. Gehört selbstverständlich in eine Schleife ;D)

char c = 125;  //Irgendein Byte
char s[8] = {'0', '0', '0', '0', '0', '0', '0', '0'};

if(c-128 > 0)
{
c -= 128;
s[8] = 1;
}

if(c-64 > 0)
{
c -= 64;#
s[7] = 1;
}

etc....

Das ist allerdings kein guter Code, weil zum einen (spätestens wenn mans in ne Schleife packt und dabei pow() benutzt) das ganze ineffizent ist, außerdem ist bitshift eleganter...

Also das funzt so:
du nimmst beispielsweise einen char, und von dem möchtest du die binäre Darstellung. Dann nimmst du dazu einen anderen char und setzt den auf 1.
Dann sieht der char so aus:
00000001
So. Dann haben wir ja die bitweisen Operationen, speziell hier das bitweise UND, also &.

Wenn char c = 15, dann sieht das so aus:
c: 00001111
b: 00000001
c&b: 00000001

Also alles wie beim logischen &&, nur dass es auf jedes bit angewendet wird.

Dann verschiebe man b um 1 nach links.

b = b << 1;
(Also: 00000010 )

Dann dasselbe nochmal:
c: 00001111
b: 00000010
c&b: 00000010

Usw.

Ich hoffe, das ist verständlich.

also ich habe das jetzt so gemacht:

string bin;
int teiler = 128;

for (int i=8; i>0; i--) {
    if ((zahl/teiler) >= 1) {
       bin = bin + "1";
       zahl = zahl - teiler;
    }
    else bin = bin + "0";

    teiler = teiler/2;
}

Nicht schön, aber selten

Trotzdem noch einmal vielen Dank für Eure Hilfe!!!

MfG, Ozzy