For Schleife innerhalb einer For Schleife Problem
-
hi, ich habe bereits geschrieben, dass ich es mit 2 verschiedenen Variablen versucht habe, hat leider nichts gebracht. Ich änder es wieder. Aber das bringt leider nichts
Noch eine Idee? Danke dir.
-
Sorry, habs überlesen. 5h Domain Controller reparieren machen verrückt...
Zeig mal bitte, wie du es mit 2 Variablen machst, theoretisch müsste das Klappen. Und warum machst du nicht gleich aktposx und aktposy zu den Schleifen Variablen. Also:
for(/*ggf. initalisierung*/; aktposy < (190 * 4); aktposy += 190) for(/*ggf. initalisierung*/; aktposx < (205 * 5); aktposx += 205) foo(aktposy, aktposx);
-
Ich habe nicht daran gedacht, weil ich noch ein ziemlicher Anfänger bin.
Und eigentlich müsste es aber so gehen. Auch deine Variante funktioniert genau so nicht wie meine. Deswegen verzweifle ich gerade. Ich denke es muss ein anderes Problem geben, aber ich weiss nicht welches. Also es passiert mit deiner Variante genau dasselbe. Es wird nur eine Zeile "gemalt", bzw. wenn ich es umdrehe eine Spalte.hier ist mein code mit 2 Variablen, aber das Problem muss ja wie gesagt woanders liegen nur wo?
for(i = 0; i < 5; i++) { for(e = 0; e < 4; e++) { apply_surface(aktposX, aktposY, karte, screen); aktposY += 190; } aktposX += 205; }
P.S.: Was bedeutet diese foo? Ich habe das jetzt schon öfters gelesen.
-
foo ist einfach nur ein nichtsbedeutender universeller Funktions-/Variablen-/Klassen-Name und wird in meistens in Beispielen verwendet, vergleichbar mit dem Lorem ipsum Blindtext.
Ich seh in dem Codefragment keine Fehler, theoretisch müsste es klappen.
Der Fehler liegt woanders. Geh mal eine Liste der möglichen Fehlerquellen ab, z.B. uninitalisierte Variablen (aktposx & aktposy). Zeig außerdem mal apply_surface, vielleicht liegt der Fehler da.
Zu guter letzt empfehle ich dir mal einen Debugger zu verwenden, um das Programm mal schrittweise nach der Stelle zu durchsuchen wo es schiefläuft.
-
Achso, habe es mir fast gedacht, aber ich dachte hinter diesem foo steckt noch eine Bedeutung der einzelnen Buchstaben. Wie auch immer, hier ist der code der Funktion. Wobei da eigentlich auch nichts falsch sein kann, weil sie ja funktioniert. Also zusammengefasst: Bei den For schleifen, werden ja die Karten dargestellt, allerdings nur eine Zeile oder eine Spalte, jenachdem wie man es dreht und wendet. Der Rest ist einfach nicht da oder verschwindet.
void apply_surface(int x, int y, SDL_Surface* source, SDL_Surface* destination ) { SDL_Rect offset; offset.x = x; offset.y = y; SDL_BlitSurface(source, NULL, destination, &offset); }
-
So Problem gelöst. Danke printf konnte ich überprüfen wie sich die beiden Werte verhalten. Der Y Wert wurde einfach fröhlich weiter erhöht. Ich muss also zu Beginn einfach wieder auf den Anfangswert setzen. Klappt nun, aber danke dir trotzdem für deine Hilfe.
-
Noch als kleine Empfehlung: Aufwendig einzubauende und am Ende wieder zu entfernende Debug-Ausgaben, also dein "Y-Werte über printf ausgeben lassen", kannst du dir sparen, wenn du einen Debugger benutzt.
Erfordert etwas Einarbeitungszeit, aber leistet gerade bei solchen schwer aufzufindenden Laufzeitfehlern gute Dienste.
-
Wie mache ich das unter Linux mit dem gcc?
-
Hier mal ein kleines Tut, aber du findest unter Google bestimmt noch bessere.
#include <stdio.h> int main() { int i; for(i = 0; i < 100; i += (i+1)*2) //Komplizierte, Fehleranfällige Berechnung ;) printf("Ein ganz wichtiger Wert im Programm: %d\n", i); return 0; }
Zuerst mal musst du den GCC ein Argument mit auf den Weg geben, dass er überhaupt Debug-Infos erzeugt. Das debuggen von Programmen ist ohne Debug-Infos zwar möglich, aber extrem umständlich und hakelig. Der Schalter
-g
sorgt dafür, dass die Debug-Informationen erstellt werden.gcc [b]-g[/b] -o testprog testprog.c
So, jetz haben wir eine ausführbare Datei mit der wir den Debugger füttern können:
gdb testprog
Um später Variablenwerte etc. überprüfen zu können müssen wir erstmal einen Breakpoint setzten. Wenn das Programm diese Stelle erreicht soll es unterbrochen werden, damit wir unsere Checks ausführen können. Es gibt verschiedene Breakpoint-Arten und Möglichkeiten sie zu setzen; ich beschränke mich hier mal auf die einfachste. Allgemein sagen wir dem Debugger nur
break <dateiname>:<zeile>
. In unserem Fall werden wir die Zeile in der Schleife, also Zeile 7, aus testprog.c benutzen:(gdb) break testprog.c:7
So nun können wir das Programm endlich ausführen.
(gdb) run
Wie erwartet wird es unterbrochen:
(gdb) run Starting program: p:/Tut/testprog Breakpoint 1, main () at testprog.c:7 7 printf("Ein ganz wichtiger Wert im Programm: %d\n", i); (gdb)
Nun können wir die Variable ausgeben (man könnte natürlich noch viel mehr tun, aber ich will ja nur die Grundlagen erklären). Dazu benutzen wir
print
:(gdb) print i
Wie erwartet, ist i beim ersten Schleifendurchgang 0.
(gdb) print i $1 = 0 (gdb)
Jetzt setzen wir das Programm mit
continue
fort, und landen wieder beim Breakpoint:(gdb) continue
Jetzt können wir uns wieder die Variable anzeigen lassen. Erwartungsgemäß hat sie jetzt den Wert 2.
Wenn wir das Spiel nocheinmal wiederholen hat sie den Wert 8 ( 2+(2+1)*2 ).So genug Variablen ausgegeben, wir wollen den Breakpoint wieder löschen. Das geht ganz einfach mit
clear <Breakpoint>
:(gdb) clear testprog.c:7
Wenn wir jetzt noch einmal "continuen" wird das Programm unterbrechungsfrei fortgesetzt und beendet.
Das sind natürlich nur die einfachsten Grundlagen; Google ist wie gesagt dein Freund.
Außerdem bin ich kein Linux- und GCC-Profi, daher alle Angaben ohne Gewähr. Müsste aber trotzdem klappen.
-
Danke für deine Erklärung. Ich werde es in Zukunft ausprobieren, wenn es denn mal größer und ernster wird. Aber so habe ich mit printf simpel und sehr schnell den Fehler gefunden.
Wenns soweit ist, weiss ich ja wo ich gucken muss fürs' debuggen.
LG, Benson
-
Stimmt schon, in deinem Fall war printf einfacher. Aber wenn du mehr als 10 Variablen überwachen willst, und dass dann noch in rekursiven Funktionen oder Schleifen (= viele Ausgaben nacheinander), wird es, mangels Unterbrechung einfach zu unübersichtlich. Außerdem ist Variablen ausgeben ja nur die Spitze des Eisberges, was ein Debugger kann.
Die Benutzung von GDB ist wirklich etwas kompliziert, aber es gibt auch GUI-Frontends, die sie vereinfachen. Und falls du eine IDE verwendest: Viele IDEs (unter Linux) haben entweder eigene Debugger mitgeliefert oder bieten Unterstützung für GDB an. Dann kannst du die Breakpoints oftmals dierekt im Code-Editor setzen (meist ist dafür ein Klick in den "Streifen" zwischen eigentlichem Code und Zeilennummer nötig (zumindest in Code-Blocks)).