for to do: 0 to -1

[Nogge]

Hallo Community,
Ich habe ein sehr merkwürdiges Verhalten in einer meiner for-Schleife gefunden (s. Anhang). Nach meinen Informationen sollte die Schleife überhaupt nicht ausgeführt werden:

Zitat von Delphi-Hilfe:

If initialValue is greater than finalValue in a for...to statement, or less than finalValue in a for...downto statement, then statement is never executed.

Kann mir jemand sagen, warum die Schleife trotzdem ausgeführt wird?

mfg Nogge

[sakura]

Von was für einem Typ ist V?

......

[Nogge]

Ah, ok. *schäm*
"v" ist vom Typ Byte, der natürlich gar keine negativen Werte annehmen kann...

Vielen Dank, sakura.

[sakura]

Zitat von Nogge:

Ah, ok. *schäm*
"v" ist vom Typ Byte, der natürlich gar keine negativen Werte annehmen kann...

Vielen Dank, sakura.

Gut erkannt und bitte

......

[omata]

Glückwunsch,

das ist der älteste Fehler.

Ich vermute mal, du hast natürlich nicht die Bereichsprüfung an, oder?
Dann würde dir der Compiler auch mehr helfen.

Naja, wie dem auch sei.
Deine Variable REMPILLAR = 0 und da du noch einen abziehst, würde dort eigentlich -1 rauskommen. Da im Datentyp Byte die -1 als 255 dargstellt wird, läufte deine Schleife von 0 bis 255.

Wie gesagt mit einer Bereichsprüfung wird diese Geschichte auch geprüft!

Also entweder immer Integer für die Laufvariable benutzen (was blödsinn ist) oder nie den Endbereich mit -1 verändern, sondern in der Schleife bei der Verwendung der Laufvariablen einen abziehen.

MfG
Thorsten

[himitsu]

Zitat von omata:

Ich vermute mal, du hast natürlich nicht die Bereichsprüfung an, oder?

Was aber keine wirklich Lösung ist, dann dadurch wird zusätzlicher Code (nämlich die Fehlerprüfung) in das Programm eingebaut wird, was erstens das Programm größer und natürlich auch etwas langsamer macht.
Und wenn ein Programm richtig/fehlerlos programmiert ist, dann ist dieses auch total sinnlos.

Zitat von omata:

Also entweder immer Integer für die Laufvariable benutzen (was blödsinn ist) oder nie den Endbereich mit -1 verändern, sondern in der Schleife bei der Verwendung der Laufvariablen einen abziehen.

Ist ja noch schlimmer.
also statt nur einmal im Rumpf der Schleife etwas abzuziehen, soll man das jetzt also (unter Umständen) mehrmals innerhalb der Schleife machen?


Es ist doch viel besser gleich die Ursache zu beheben?
Also entweder die Datentypen anpassen, oder nur eine winzige Prüfung selber einzufügen

Delphi-Quellcode:

if REMPILLAR > 0 then
  for v := 0 to (REMPILLAR - 1) do
    ...

Hier wird auf größer 0 geprüft, da es einen optimaleren Code erzeugt.
eigentlich natürlich if REMPILLAR >= 1 then, also größer/gleich der Wert, welcher Abgezogen wird.

[omata]

Zitat von himitsu:

Was aber keine wirklich Lösung ist, dann dadurch wird zusätzlicher Code (nämlich die Fehlerprüfung) in das Programm eingebaut wird, was erstens das Programm größer und natürlich auch etwas langsamer macht.
Und wenn ein Programm richtig/fehlerlos programmiert ist, dann ist dieses auch total sinnlos.

Es geht hier ums Entwickeln, dann sollte die Prüfung an sein. Ausserdem ist es heutzutage mit grossen Platten und schnellen Rechnern nicht mehr so wichtig, dass die Anwendung klein und super schnell ist. Da kommt es auf die paar KB auch nicht an. Es ist viel mehr wichtig, dass die Anwendung richtig funktioniert und eine ordentliche Fehlersuche möglich ist.

Zitat von himitsu:

Zitat von omata:

Also entweder immer Integer für die Laufvariable benutzen (was blödsinn ist) oder nie den Endbereich mit -1 verändern, sondern in der Schleife bei der Verwendung der Laufvariablen einen abziehen.

Ist ja noch schlimmer.
also statt nur einmal im Rumpf der Schleife etwas abzuziehen, soll man das jetzt also (unter Umständen) mehrmals innerhalb der Schleife machen?

Wie du selber schreibst, "unter umständen" richtig. Wenn du mal Compilerbau hörst, wirst du erfahren, dass man absichtlich den Quellcode nicht optimieren soll. Die heutigen Compiler übernehmen die Optimierung des Codes. Man selbst soll übersichtlich und sicher programmieren.

Zitat von himitsu:

Es ist doch viel besser gleich die Ursache zu beheben?
Also entweder die Datentypen anpassen, oder nur eine winzige Prüfung selber einzufügen

Delphi-Quellcode:

if REMPILLAR > 0 then
  for v := 0 to (REMPILLAR - 1) do
    ...

Hier wird auf größer 0 geprüft, da es einen optimaleren Code erzeugt.
eigentlich natürlich if REMPILLAR >= 1 then, also größer/gleich der Wert, welcher Abgezogen wird.

Das mit dem Typ hatte ich schon geschrieben. Und die IF-Anweisung davor, ist genau folgendes
for v := 0 to REMPILLAR do wenn man die -1 weglässt.

Man kann das sehen, wie man will.
Und nun könnt ihr (z.B. Luckie) mich wieder in der Luft zerreissen...

[malo]

Zitat von omata:

. Und die IF-Anweisung davor, ist genau folgendes:for v := 0 to REMPILLAR do wenn man die -1 weglässt.

Unsinn.
Einmal die andere Schleife zum Vergleich:

Delphi-Quellcode:

if REMPILLAR > 0 then
  for v := 0 to (REMPILLAR - 1) do

Nehmen wir an REMPILLAR ist 0. Dann würde bei die Schleife mit dem IF am Anfang gar nicht erst starten. Die andere aber schon.

Nehmen wir jetzt mal an REMPILLAR ist 5. Dann würde bei oberer Schleife (ohne IF) folgendes passieren:
for v := 0 to 5 do Bei der anderen (die mit der Abfrage am Anfang) folgendes:
for v := 0 to 4 do Man sieht, die Unterschiede sind schon vorhanden.

[omata]

Ja, du hast natürlich rechts, sorry.

Ist wohl doch schon zu spät.

Stimmt, es müsste dann natürlich
for v:=1 to REMPILLAR do sein.

Danke für den Hinweis.

[kalmi01]

Moin, moin, himitsu,

Zitat:

Was aber keine wirklich Lösung ist, dann dadurch wird zusätzlicher Code (nämlich die Fehlerprüfung) in das Programm eingebaut wird, was erstens das Programm größer und natürlich auch etwas langsamer macht.

Bei mir macht es definitiv keinen Unterschied ob Bereichsprüfung+I/O-Prüfung an hab oder nicht, die Exe, mit der ich getestet habe, ist in beiden Fällen 1366016 Bytes.

Das ist mir schon früher aufgefallen, dass es bei Delphi 7 anscheinend keinen Einfluss auf die Programmgrösse hat, welche Prüfungen man aktiviert.