Schleifen wiederholen

[Kegasetu]

Hallo Zusammen.
Ich stoße mittlerweile ein Bisschen an meine Grenzen. Das Problem, ich will über einen Integer einen Wert eingeben, über welchen bestimmt wird, wie oft eine Schleife durchlaufen wird. Diese Schleifen können als Exponenten angesehen werden.

Hier ein kleines Beispiel zu der manuellen Lösung des Problems:

Delphi-Quellcode:

for z1 := 1 to 10 do
  begin
    l12 := l11 +0.1;
    l11 := l11 + 0.1;              
      for z2 := 1 to 10 do
      begin
        l13 := l12 + 0.1;
        l12 := l12 + 0.1;
          for z3 := 1 to 10 do
          begin
          l14 := l13 + 0.1;
          l13 := l13 + 0.1;
            for z4 := 1 to 10 do
            begin
              l15:= l14 + 0.1;
              l14:= l14 + 0.1;
                for z5 := 1 to 10 do
                   ..

Das ist so natürlich überaus unpraktisch. Ich kam nun auf die Idee eine Funktion entsprechend zu erstellen, jedoch bin ich auch nach längerem Überlegen nicht auf eine Lösung gekommen...

Noch ein Hinweis, es werden maximal 20 Loops durchlaufen.

Hat jemand vielleicht eine Idee?

[Der schöne Günther]

Warum hast du da tausend einzelne Variablen und kein Array?

[Kegasetu]

Zitat:

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

Warum hast du da tausend einzelne Variablen und kein Array?

Das ist aus älteren Beiträgen zu entnehmen. Die Bezeichnung hilft mir bei meinen Formeln nicht durcheinander zu kommen.

[ConnorMcLeod]

Etwas in der Art?

Delphi-Quellcode:

procedure Machwas(AWieoft: Integer);
var
  LiLooper: Integer;
begin
  for LiLooper := 1 to AWieoft do begin
    //
  end;
end;

[Kegasetu]

Zitat:

Zitat von ConnorMcLeod (Beitrag 1475990)

Etwas in der Art?

Delphi-Quellcode:

procedure Machwas(AWieoft: Integer);
var
  LiLooper: Integer;
begin
  for LiLooper := 1 to AWieoft do begin
    //
  end;
end;

Ja, so ungegefähr. Aber ich verstehe noch nicht so ganz wie ich mir das zusammenstelle.

[Jasocul]

Zitat:

Zitat von Kegasetu (Beitrag 1475988)

Zitat:

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

Warum hast du da tausend einzelne Variablen und kein Array?

Das ist aus älteren Beiträgen zu entnehmen. Die Bezeichnung hilft mir bei meinen Formeln nicht durcheinander zu kommen.

Sorry, aber das lasse ich nicht so stehen.
Ob man

Delphi-Quellcode:

l12 := l11 + 0.1

schreibt oder

Delphi-Quellcode:

l[12] := l[11] + 0.1

ändert an der Lesbarkeit nicht viel und man kommt dabei auch nicht mehr oder weniger durcheinander.
Aber sei es so, wie du möchtest.

Zitat:

Zitat von Kegasetu (Beitrag 1475993)

Zitat:

Zitat von ConnorMcLeod (Beitrag 1475990)

Etwas in der Art?

Delphi-Quellcode:

procedure Machwas(AWieoft: Integer);
var
  LiLooper: Integer;
begin
  for LiLooper := 1 to AWieoft do begin
    //
  end;
end;

Ja, so ungegefähr. Aber ich verstehe noch nicht so ganz wie ich mir das zusammenstelle.

Du brauchst noch zwei weitere Parameter, nämlich die Werte, die du in der Schleife verändern willst:

Delphi-Quellcode:

procedure Machwas(AWieoft: Integer; Var L1, L2 : <Dein-Float-Typ>);
var
  LiLooper: Integer;
begin
  for LiLooper := 1 to AWieoft do begin
    L1 := L2 + 0.1;
    L2 := L2 + 0.1;
  end;
end;

Allerdings wird es dann immer noch nicht funktionieren, da deine Schleifen geschachtelt sind. Somit kannst du die Prozedur nicht iterativ aufrufen. Hier hilft meiner Ansicht nach nur ein rekursiver Aufruf, was aber nicht geht, weil du keinen Zähler für die Rekursionstiefe hast. Dafür müsstest du deine Werte in einem Array speichern.
Also entweder feste Variablenbezeichner für deine Werte und deine geschachtelten Schleifen nehmen oder auf Array umstellen und rekursiv programmieren.

Aber vielleicht fällt ja noch jemandem etwas besseres ein.

[Kegasetu]

Zitat:

Zitat von Jasocul (Beitrag 1475994)

Zitat:

Zitat von Kegasetu (Beitrag 1475988)

Zitat:

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

Warum hast du da tausend einzelne Variablen und kein Array?

Das ist aus älteren Beiträgen zu entnehmen. Die Bezeichnung hilft mir bei meinen Formeln nicht durcheinander zu kommen.

Sorry, aber das lasse ich nicht so stehen.
Ob man

Delphi-Quellcode:

l12 := l11 + 0.1

schreibt oder

Delphi-Quellcode:

l[12] := l[11] + 0.1

ändert an der Lesbarkeit nicht viel und man kommt dabei auch nicht mehr oder weniger durcheinander.
Aber sei es so, wie du möchtest.

Zitat:

Zitat von Kegasetu (Beitrag 1475993)

Zitat:

Zitat von ConnorMcLeod (Beitrag 1475990)

Etwas in der Art?

Delphi-Quellcode:

procedure Machwas(AWieoft: Integer);
var
  LiLooper: Integer;
begin
  for LiLooper := 1 to AWieoft do begin
    //
  end;
end;

Ja, so ungegefähr. Aber ich verstehe noch nicht so ganz wie ich mir das zusammenstelle.

Du brauchst noch zwei weitere Parameter, nämlich die Werte, die du in der Schleife verändern willst:

Delphi-Quellcode:

procedure Machwas(AWieoft: Integer; Var L1, L2 : <Dein-Float-Typ>);
var
  LiLooper: Integer;
begin
  for LiLooper := 1 to AWieoft do begin
    L1 := L2 + 0.1;
    L2 := L2 + 0.1;
  end;
end;

Allerdings wird es dann immer noch nicht funktionieren, da deine Schleifen geschachtelt sind. Somit kannst du die Prozedur nicht iterativ aufrufen. Hier hilft meiner Ansicht nach nur ein rekursiver Aufruf, was aber nicht geht, weil du keinen Zähler für die Rekursionstiefe hast. Dafür müsstest du deine Werte in einem Array speichern.
Also entweder feste Variablenbezeichner für deine Werte und deine geschachtelten Schleifen nehmen oder auf Array umstellen und rekursiv programmieren.

Aber vielleicht fällt ja noch jemandem etwas besseres ein.

Erstmal vielen Dank für die Unterstützung!

Ich verzichte nicht im allgemeinen auf Arrays, sondern nur in diesem speziellen Fall.

Das Problem sehe ich auch in der Verschachtelung und das ist der Punkt, an dem ich nicht weiterkomme. Nimm es mir bitte nicht übel, aber ich verstehe nicht ganz so viel der Informationstechnik. Ich selber bin auch nur kurzweilig gezwungen mich damit auseinander zusetzten.

[Jasocul]

Zitat:

Zitat von Kegasetu (Beitrag 1475997)

Das Problem sehe ich auch in der Verschachtelung und das ist der Punkt, an dem ich nicht weiterkomme. Nimm es mir bitte nicht übel, aber ich verstehe nicht ganz so viel der Informationstechnik. Ich selber bin auch nur kurzweilig gezwungen mich damit auseinander zusetzten.

Sorry, ich wollte nicht vorwurfsvoll bei dir ankommen. Ich bin eher der pragmatische Typ.
Rekursiv heißt, dass du eine Prozedur oder Funktion schreibst, die sich selbst wieder aufruft. Dafür brauchst du ein Kriterium, dass die Rekursion irgendwann abbricht. Bei einem Array könnte es die Arraygröße sein. Bei festen Variablen habe ich spontan keine Idee, wie man das sinnvoll realisieren kann.
Daher bleibt nur deine Variante mit der Verschachtelung übrig.

[Kegasetu]

Zitat:

Zitat von Jasocul (Beitrag 1475998)

Daher bleibt nur deine Variante mit der Verschachtelung übrig.

An sich ist das mit der Verschachtelung gar nicht so schlimm, mir ist nur wichtig, dass es irgendwie funktioniert. Ich erinnere mich düster an Batch Dateien, welche über einen GoTo Befehl verfügen. Bei Delphi gibt es diese Möglichkeit auch so ähnlich. Ergibt es Sinn, sich damit auseinander zu setzten? Ich habe mich mal ein kleines bisschen darüber informiert, aber meist wird davon abgeraten.

[himitsu]

Zitat:

Zitat von Kegasetu (Beitrag 1475988)

Das ist aus älteren Beiträgen zu entnehmen. Die Bezeichnung hilft mir bei meinen Formeln nicht durcheinander zu kommen.

Und was ist dann der Unterschied zwischen l14, l[14], myvars[l14] und myvars['l14'] ?

OK, Letzteres ist unünstiger, da der Compiler hier nicht schon alles prüfen kann und ein ungültiger Bezeichner erst zur Laufzeit knallen "kann"
und natürlich auch die Codevervollständigung hier nicht hilft.