Fehlersuche: For-Schleife läuft endlos
-
Ich stehe vor einem Rätsel.
Ich möchte einfach die Zahl "zahl=777" binär darstellen in einem Array b[0]-b[15] und dazu verknüpfe ich das Testbit (dass immer eins nach Links geschoben wird) via dem Und-Operator mit der Zahl.
Ich habe den ganzen Abend rumprobiert - ich verstehe nicht, warum.
Wenn ich das x im Array vom x in der For-Schleife "entkoppele", z.B. dass ich in der For-Schleife beim x bleibe, den Array aber mit einer anderen laufenden Varaibelen y fülle b[y] ist alles ok.
Das x in der For-Schleife und die Befehle b[x]=1 bzw.b[x]=2 scheinen sich zu stören und ich verstehe nicht warum.
Nach 16 Schritten fängt der Prozess wieder bei x=0 in der For-Schleife an. Kann mir jemand sagen, wo der Fehler steckt?
Kenntnisstand: Ich bin Anfänger in C.
/*Dez. -> Binaer*/ #include <stdio.h> int main(void) { int zahl=777; int testbit=1; int x=0; int b[15]; printf("\n"); for(x=0; x<=15; x=x+1) { if (zahl&testbit) { b[x]=1; /*Hier hakt es */ } else { b[x]=0; /* und/oder hier */ } testbit=testbit<<1; } return 0; }
-
mactronic schrieb:
Nach 16 Schritten fängt der Prozess wieder bei x=0 in der For-Schleife an. Kann mir jemand sagen, wo der Fehler steckt?
int x=0; int b[15]; printf("\n"); for(x=0; x<=15; x=x+1) {Du schreibst im letzten for-Durchlauf in b[15] etwas rein, d.h. du schreibst über die Arraygrenzen hinaus und evtl. in x(!), was die Schleifenendbedingung evtl. beeinflusst.
Verwende mal b[16].
-
Danke, genau das hat geholfen.
Ich wollte natürlich 16 Bit abtesten, habe mich aber von der "15" verleiten lassen...
Nochmals danke,auch für die schnelle Hilfe.
Aber,... merkwürdig ist es schon, dass eine Falschbehandlung des Arrays x[15] sich auf die Variabele x auswirkt. Das sollten doch zwei verschiedene Speicherräume sein.
Oder hängen die beiden "x" möglicherweise über einen Zeiger zusammen? Interessant...
-
mactronic schrieb:
Oder hängen die beiden "x" möglicherweise über einen Zeiger zusammen? Interessant...
Wenn du auf das Array mit einem ungueltigen Index zugreifst, dann ist das Verhalten undefiniert. Es kann also alles passieren - das Programm kann abstuerzen, es kann falsche Ausgaben liefern etc.
In deinem Fall liegt wohl x im Speicher gerade hinter dem Array.
Die Variable b ist nur ein Zeiger auf das erste Element des Arrays. Wenn du dann b + 16 rechnest, dann bist du bei der Variable x. Deswegen wird in deinem Code dann die Variable x veraendert.
-
Lokaqle Variablen werden auf dem Stack abgelegt. Dieser wächst i.A von oben (hohe Adresse) nach unten.
Da wird jetzt nacheinander Speicher für zahl, testbit, x und das Array b belegt
+-------+ | zahl | +-------+ |testbit| +-------+ | x | +-------+ | b[14] | +-------+ | b[13] | +-------+ | b[12] | +-------+ ... +-------+ | b[1] | +-------+ | b[0] | +-------+Wenn du jetzt auf b[15] zugreifst, überschreibst du x.
Das muss so nicht sein, der Compiler kann auch optimieren und die Variablen in Register halten.
-
void Bits(unsigned short x){ int bits = 4 * sizeof(x); int i, z=0; int f[]; for(i = bits - 1; i >= 0; i--) { if((x >> i) & 1){ f[z]=1; } else{ f[z]=0; } z++; } }müsste stimmen, habs aber noch nicht ausprobiert
edit1: alternativ
void Bits(unsigned short x){ int bits = 4 * sizeof(x); int i, z=0; int f[]; for(i = bits - 1; i >= 0; i--) { f[z]=(x >> i) & 1; z++; } }edit2:
und dein fehler ist glaub ich:
testbit=testbit<<1;
stattdessen gehört da meiner meinung nach
testbit=testbit>>1; hin
da musst du dein programm dann halt drauf abstimmen, aber hier meine erklärung:
01010101 << 1 &1=1
10101010 << 1 &1=0
01010100 << 1 &1=0
10101000 << 1 &1=0
01010000 << 1 &1=0
10100000 << 1 &1=0
01000000 << 1 &1=0
10000000 << 1 &1=0
00000000 << 1 &1=0 --> testbit=10000000-->
allerdings:
01010101 >> 1 &1=1
00101010 >> 1 &1=0
00010101 >> 1 &1=1
00001010 >> 1 &1=0
00000101 >> 1 &1=1
00000010 >> 1 &1=0
00000001 >> 1 &1=1
00000000 >> 1 &1=0 --> testbit=10101010
--> drehe das bit um --> testbit=01010101 
--> 
edit3:
ach ich hab es immer noch nicht ausprobiert, halte dich einfach an das edit2^^
edit4:
damit ergibt sich folgender code
int main() { int x=432; int bits = 4 * sizeof(x); int i, z=-1; int f[bits-1]; for(i = bits - 1; i >= 0; i--) { f[z]=(x >> i) & 1; z++; } for(i=0; i<bits-1; i++){ printf("%d", f[i]); } return 0; }edit5:
dieser code funktioniert einwandfrei und hilft bei jeder bitlänge.
also wenn du double verwendest, kannst du die größte bitlänge haben und das beste an dieser funktion ist, dass du die funktion nicht ändern musst wenn du sie in ein anderes programm einbinden willst. sie funktioniert überall! deswegen hab ich die mir auch gleich in meine header datei eingebunden^^MFG
uncannysnake
-
uncannysnake schrieb:
int main() { int x=432; int bits = 4 * sizeof(x); int i, z=-1; int f[bits-1]; for(i = bits - 1; i >= 0; i--) { f[z]=(x >> i) & 1; z++; } for(i=0; i<bits-1; i++){ printf("%d", f[i]); } return 0; }edit5:
dieser code funktioniert einwandfrei und hilft bei jeder bitlänge.
also wenn du double verwendest, kannst du die größte bitlänge haben und das beste an dieser funktion ist, dass du die funktion nicht ändern musst wenn du sie in ein anderes programm einbinden willst. sie funktioniert überall! deswegen hab ich die mir auch gleich in meine header datei eingebundenAch ja wirklich?
Der Code ist totaler Schrott. Er produziert undefiniertes Verhalten und arbeitet nicht für "alle" Bitlängen und schon gar nicht "überall".
Merke dir mal, dass (d)ein Programm nicht "einwandfrei überall" funktioniert, bloß weil es bei dir in deinem Umlauf gerade mal nicht gleich abstürzt und der Compiler keine Fehler wirft.
