Delphi for Schleife -> Warnung

[kagi3624]

Hallo, weil ich meine liste in Segmenten durchlaufen muss, weise ich der Indexvariable den Startwert außerhalb, um überhaupt den Code kompelieren zu können musste ich die Variable sich selbst zuweisen :roll:

Code:

t := 0;
j := 100; 
for t := t to j do begin
 //iwas...
end;

Der Code macht das, was es machen soll, allerdings kommt eine Warnung

Code:

[Warnung] frmAnalysis.pas(1039): FOR-Schleifenvariable 't' kann nach Durchlauf undefiniert sein

Wie sieht denn die richtige Schreibweise für so eine for-Schleife bzw. gibt es sie überhaupt? Bei C++ soll man ja das t da einfach weglassen aber das führt bei Delphi zu einer Fehlermeldung beim kompilieren

Code:

t=0;
for(; t<=100; ++t)

[Neutral General]

Also wenn ich sowas mache, nutze ich immer eine 2. Variable. Hab deine Variante ehrlich gesagt noch nie ausprobiert.

Delphi-Quellcode:

start := 100;
for i:= start to ende do
begin

end;

[Lemmy]

Zitat:

Zitat von kagi3624 (Beitrag 1458727)

Der Code macht das, was es machen soll, allerdings kommt eine Warnung

Code:

[Warnung] frmAnalysis.pas(1039): FOR-Schleifenvariable 't' kann nach Durchlauf undefiniert sein

Die Warnung sagt genau das was das Problem ist: t ist nach dem Durchlauf undefiniert (kann undefiniert sein) - und Du verwendest T NACH der Schleife.

[kagi3624]

Zitat:

Zitat von Lemmy (Beitrag 1458729)

Die Warnung sagt genau das was das Problem ist: t ist nach dem Durchlauf undefiniert (kann undefiniert sein) - und Du verwendest T NACH der Schleife.

Das ist mir schon klar, meine Frage ist, ob es eine Möglichkeit gibt das t wegzulassen, so dass es als global angesehen wird.

Zitat:

Zitat von Neutral General (Beitrag 1458728)

Also wenn ich sowas mache, nutze ich immer eine 2. Variable. Hab deine Variante ehrlich gesagt noch nie ausprobiert.

Danke, das kam mir überhaupt nicht in den Sinn.

[Der schöne Günther]

Dein Problem ist nicht die For-Schleife, sondern dass du danach auf die Zählervariable zugreifst und das ist nicht erlaubt wenn man die Schleife nicht aktiv verlassen hat (z.B. mit

Delphi-Quellcode:

break

).

Beispiel:

Delphi-Quellcode:

procedure p();
var
   x, y: Integer;
begin
   x := 0;
   y := 5;
   for x := x to y do
      WriteLn(x);

   WriteLn('Last value: ', x);
end;

Ergibt:

Code:

0
1
2
3
4
5
Last value: 6

x ist nach der Schleife 6 obwohl du gar nicht bis 6 gezählt hast. Davor warnt dich der Compiler und er hat Recht. Wenn du x nach der Schleife nochmal verwenden willst solltest du dir den letzten Wert entweder in einer zusätzlichen Variable merken oder die Schleife aktiv verlassen.

Beispiel:

Delphi-Quellcode:

procedure p();
var
   x, y: Integer;
begin
   x := 0;
   y := 5;
   for x := x to y do
      begin
         WriteLn(x);
         if(x = y) then
            Break;
      end;
   WriteLn('Last value: ', x);
end;

[himitsu]

Zitat:

Zitat von Der schöne Günther (Beitrag 1458732)

x ist nach der Schleife 6 obwohl du gar nicht bis 6 gezählt hast.

X kann nachher auch 0 sein, falls der Compiler der Meinung war, dass es "intern" rückwärts für ihn besser sei.

Man kann die Schleifenvariable danach aber auch problemlos weiter benutzen, wenn man sie vorher eben initialisiert.

Delphi-Quellcode:

X := 123;
if X = ...;

for X in 0 do 3000 do begin
  ...
end;

X := 789;
if X = ...;

[Der schöne Günther]

Dann ist es aber keine Schleifenvariable mehr, sondern eine recyclete Variable mit irgendwas. Ich denke es ging ihm darum den Wert des letzten Durchlaufs zu behalten.

[Neutral General]

Es ging ihm einfach darum wie man es richtig/ordentlich macht ohne eine Warnung zu bekommen.

[DieDolly]

Ich würde es wegen der besseren Lesbarkeit so machen. Das gibt auch keine Compiler-Warnung.

Delphi-Quellcode:

var
 j: Integer;
begin
 j := 0;
 repeat
  if j = N then // falls man eine Kondition braucht
   Break;

  // ...

  Inc(j);
 until j = 100;
end;

[bcvs]

Oder eine while - Schleife benutzen, wenn man volle Kontrolle über die Schleifenvariable haben will:

Delphi-Quellcode:

t := 0;
j := 100;
while t <= j do begin
 //iwas...
 inc(t); 
end;

Dabei nur das inc nicht vergessen. Das ist gerne mein Standardfehler, und dann wundere ich mich über die Endlosschleife.:)

[DieDolly]

Zitat:

Oder eine while - Schleife benutzen

Dann aber im Delphi-Style :thumb:

Delphi-Quellcode:

while t <= j do
 begin

[Neutral General]

Ich würds so machen:

Delphi-Quellcode:

label _loop;
asm
  mov ecx, 0
  mov edx, 100
_loop:
  // iwas
  inc ecx
  cmp ecx, edx
  jng _loop
end;

[pesi]

Vielleicht bin ich ja manchmal etwas einfach gestrickt, aber ich verstehe nicht warum t die Schleifenvariable sein muss und gleichzeitig der Anfangswert???? Noch nie gesehen so ein Konstrukt, kommt mir auch ziemlich sinnfrei vor, oder??? Warum nicht eine wirkliche, also eigenständige, Schleifenwariable XXX verwenden???

Code:

t := 0;
j := 100;
for XXX := t to j do begin
 //iwas...
end;

[DieDolly]

Zitat:

Vielleicht bin ich ja manchmal etwas einfach gestrickt, aber ich verstehe nicht warum t die Schleifenvariable sein muss und gleichzeitig der Anfangswert????

Wer sagt denn, dass das sein muss? Stimmt doch gar nicht.

Delphi-Quellcode:

for i := 0 to 99 do
 begin
 end;

[himitsu]

Klar kann die Schleifenvariable und der Startwert die selbe Variable sein, aber man sollte/darf eben nach der Schleife nicht mehr den Wert dieser Variable verwenden.
Man kann sogar für Schleifenvariable und Endwert die selbe Variable verwenden, da Delphi sich von dem Endwert sowieso eine Kopie macht, weswegen man bei Schleifen mit Delete etwas aufpassen muß.

Delphi-Quellcode:

x := 100;
for x := 0 to x do 
  ;

[kagi3624]

Zitat:

Zitat von pesi (Beitrag 1458742)

Vielleicht bin ich ja manchmal etwas einfach gestrickt, aber ich verstehe nicht warum t die Schleifenvariable sein muss und gleichzeitig der Anfangswert???? Noch nie gesehen so ein Konstrukt, kommt mir auch ziemlich sinnfrei vor, oder??? Warum nicht eine wirkliche, also eigenständige, Schleifenwariable XXX verwenden???

Code:

t := 0;
j := 100;
for XXX := t to j do begin
 //iwas...
end;

Das hängt damit zusammen, dass ich von C++ komme :lol: ... aus meiner Sicht macht Delphi überhaupt keinen Sinn :lol:

[Sherlock]

Delphi ist etwas wortreicher als C++, das sehe ich ein. Aber Unverständlich dürfte es nun wirklich nicht sein. :wink:

Sherlock

[hoika]

Hallo,

Zitat:

dass ich von C++ komme

Auch in c++ werden Schleifenvariablen in Register kopiert (z.B. ax,eax).
Und da es nicht genügend Register gibt,
können diese Register nach dem Ende der Schleife wieder anderweitig belegt werden/sein.

[Moombas]

Also ich mache es in der Regel so, das die Schleifenvariable ihren eigene Variable hat (Beispiel gab es hier ja schon). Jedoch immer mit eindeutiger Bezeichnung wofür gezählt wird (wenn möglich):

Delphi-Quellcode:

for Col := 0 to Listen_XLS.ColCount - 2 do
begin
   for Row := 0 to Listen_XLS.RowCount - 1 do
   begin
     Listen_XLS.Cells[Col, Row] := Listen_XLS.Cells[Col + 1, Row];
   end;
end;

bzw. wenn es vorher definiert werden muss wo ich starte/aufhöre auch mal so (nur ein Sample):

Delphi-Quellcode:

start   := 0;
EndeCol := Listen_XLS.ColCount - 2;
EndeRow := Listen_XLS.RowCount - 1;

for Col := start to EndeCol do
begin
   for Row := start to EndeRow do
   begin
     Listen_XLS.Cells[Col, Row] := Listen_XLS.Cells[Col + 1, Row];
   end;
end;

So kann man, sofern man es braucht, diese gesetzten Werte auch mehrfach verwenden. Das erleichtert auch ggf. Anpassungen, wenn aus irgendwelchen Gründen, sich diese Start/Endpunkte verschieben sollen, da nur die Variable geändert werden muss.

[himitsu]

@pesi ohne große Ahnung vom Programmieren zu haben, ist die Delphi-Schleife IMHO einfacher,
denn da gibt es nur FROM und TO, während man in C die Initialisierung, die Abbruchbedingung und die Inkrementierung erstmal kappieren muß.
Dafür kann man in C die For-Schleife nativ auch wesentlich komplexer benutzen.

https://www.w3schools.com/cpp/cpp_for_loop.asp
http://docwiki.embarcadero.com/RADSt...For_Statements
Und mal ganz im Ernst ... ohne genauere Vorkentniss, weiß man bein C++ hier nicht was wo rein muß.

Code:

for (statement 1; statement 2; statement 3) {

Delphi-Quellcode:

for counter := initialValue to finalValue do

for counter := initialValue downto finalValue do

Und ich hab schon viele Wikis/Tutorials/Hilfen gesehen, wo es so "unbezeichnend" dokumentiert ist und man erst das Kleingedruckte genau lesen muss.

Auch wenn es anders ginge.
http://docwiki.embarcadero.com/RADSt.../For_(C%2B%2B)
https://en.cppreference.com/w/cpp/language/for



In C ist der For-Loop quasi nur eine Kurzschreibweise (Makro) für eine While-Schleife inkl. Initialisierung und Inkrementierung.

In Delphi ist es halt was Eigenes. (auch wenn es intern auch fast wie 'ne WHILE arbeitet, inkl. einer Temp-Variable für das Ende)
Leider ohne das STEP, was man aus BASIC und anderen Pascal-Dialekten kennt. :cry:

Da das Ende oft mit = arbeitet, gäbe es Probleme, wenn man innerhalb der Schleife den Zähler ändert. (was möglich ist, aber dann den Abbruch verhindern kann)

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  i: Integer;
begin
  //for i := 0 to 8 step 2 do begin
  for i := 0 to 8 do begin // 0 2 4 8 (Abbruch bei 9, aber da sie übersprungen wurde) 10 12 14 ... = Endlosschleife, da bei 32 Bit es wieder zur 0 zurückkehrt
    if i > 30 then
      Break;  // manueller Sicherheitsabbruch
    Memo1.Lines.Add(IntToStr(i));
    Application.ProcessMessages;
    Inc(PInteger(@i)^);  // STEP 2
  end;

Hier kann man sich mit dem FOR-IN behelfen.

Delphi-Quellcode:

// wenn GenerateSeries(From, To, Step) die Zahlenfolge als Enumerator oder dynamisches Array liefert

for i in GenerateSeries(0, 8, 2) do