Binärzähler programmieren?

[lounsome]

Hallo

Ich würde gerne einen Binärzähler programmieren (in C, C++, C# oder VB), das Ergebnis sollte in etwa so aussehen:

0000000
0000001
0000010
0000011
0000100
...
..
.
usw.


Hat von euch jemand ne Idee, wie ich das anstellen könnte?


Gruß Leo

[Monger]

Klar. Zuerst einmal solltest du dir klar darüber werden, dass es dem Computer völlig egal ist in welchem Zahlensystem er rechnet. Ob du jetzt 100b * 111b rechnest oder 4 * 7, ist unwichtig. Dein zentrales Problem ist die Darstellung.

Die meisten Sprachen dürften solche Darstellungskonvertierungen bereits im Bauch haben. Ansonsten musst du dir halt selber was basteln.

[lounsome]

Das die von mir aufgelissteten Sprachen das umwandeln von z.B. Int in Bin von Haus aus beherschen ist mir klar, nur wie bastle ich das selber.
Mir gehts eigentlich nur um´s Verständniss, wie bringe ich das in ein paar Schleifen unter?

[Legolas]

Naja, wenn du die Binärdarstellung ausgeben willst, brauchst du dir doch nur die einzelnen Bits anschauen. Also einfach mit ner entsprechenden Bitmaske über die Zahl laufen und schauen, ob an der jeweiligen Stelle ne 1 oder ne 0 steht. Konvertieren brauchst du in dem Fall eigentlich gar nichts, da die Zahlen sowieso im Binärformat vorliegen.

[Monger]

Weißt du, was eine Modulo Operation ist? Die gibt dir immer den Rest einer ganzzahligen Division aus. Also z.B. 4 / 3 MOD 1.

Zusammen mit der normalen Division kannst du dir einen Bitschieber realisieren: immer die letzte Ziffer auslesen, und danach abschneiden. Mehr Tipps kann ich dir jetzt aber wirklich nicht mehr gebe, ohne das Programm gleich selber zu schreiben! ;)

[Kampf-Sushi]

Google mal mit dec2bin.
Beispiel VB, Freihaendisch, keine Garantie dass es Funktioniert. Ich nahm die erstbeste Dec2Bin Function die ich fand.


Function Dec2Bin(ByVal n As Long) As String
Do Until n = 0
If (n Mod 2) Then Dec2Bin = "1" & Dec2Bin Else Dec2Bin = "0" & Dec2Bin
n = n \ 2
Loop
End Function

Dim i as Long
For i = 0 to 100
MsgBox Dec2Bin(i)
Next i


Wenn du die Bits schneller auslesen möchtest geht das warscheinlich am besten über die Logischen Operatoren.
2^n gibt an der jeweiligen Stelle eine eins.
2^0 => 00000001
2^1 => 00000010
2^2 => 00000100
usw
Wenn du die Zahl dann mit einer beliebigen Zahl per And verknüpfst hast du dann nur die Eins.. oder halt direkt 0
111000 And
101111
ergibt dann
101000

Hm... grad keine Zeit das ausführlicher zu erklären. Google halt mal und denk ein wenig drüber nach.

[lounsome]

Alles klar, das dürfte mir schon n ganzes Stück weiter helfen.
Danke:smile:

[Gnafoo]

Ungetestet und nur auf die schnelle dahingetippt, aber das Prinzip sollte klar werden:
Man geht zunächst jedes Bit durch. Indem man mit 1 und-verknüpft, isoliert man das letzte Bit und kann es so ausgeben. Dann muss man die Zahl um ein Bit nach rechts schieben und kann mit dem nächsten Bit weitermachen.


byte num = ...;
for(int i=0; i<sizeof(byte); i++)
{
std::cout num & 1 << std::endl;
num >>= 1;
}


Wie schon gesagt wurde kann man selbiges auch mit Modulo und der Ganzzahldivision erreichen (hier wäre das % 2 zum isolieren des letzten Bit und / 2 zum "durchschieben"). Das kann sehr nützlich sein, wenn man auch andere Zahlensysteme, wie z. B. hexadezimal unterstützen will.

[Gast]

byte num = ...;
for(int i=0; i<sizeof(byte); i++)
{
std::cout num & 1 << std::endl;
num >>= 1;
}

dort besser sizeof(num)*8, sonst würde nur Käse rauskommen

[Trap]

Die einfachste Lösung wäre:
#include<iostream>

int main(){
unsigned char x = 0;
do { std::cout << bin << x << "\n"; } while(++x); // argh, das geht nicht, es gibt nur oktal, dezimal und hexadecimal
}

Geht aber leider nicht.

[Trap]

byte num = ...;
for(int i=0; i<sizeof(byte); i++)
{
std::cout num & 1 << std::endl;
num >>= 1;
}

Das ist in noch einem Detail falsch: Es gibt die Zahl rückwärts aus. :tongue:

[Gnafoo]

Ich wollte ja nur wissen, ob ihr auch gut aufpasst ;D.

Naja ne. "Auf die schnelle dahingetippt" eben. Der Gast und Trap haben natürlich recht.

[KhanRKerensky]

#include <iostream>

template<class T>
std::string binToStr(T t)
{
std::string result;
for( int i = sizeof(T) * 8 - 1 ; i >= 0; --i)
result.push_back( std::abs( (t & 1 << i ) >> i ) + 0x30 );

return result;
}

int main()
{
for( int i = 0; i < 10; ++i)
std::cout << i << ": " << binToStr(i) << std::endl;
for( short i = 0; i < 10; ++i)
std::cout << i << ": " << binToStr(i) << std::endl;
for( char c = 'a'; c <= 'z'; ++c)
std::cout << c << ": " << binToStr(c) << std::endl;

return 0;
}

Ein Aufruf ist natürlich nur mit ordinalen Datentypen sinnvoll. Wenn man da nen Pointer reinschickt wird der Compiler recht schnell meckern.