For-Schleife als Template mit Prozedur als Parameter?

[LTE5]

Ich weiß nicht wie ich das erklären soll. Ich habe das schon einmal gesehen weiß aber nicht wie es heißt und wie ich es finden kann.
Kann man den Schleifenkopf einer For-Schleife irgendwie als eine Art Template als Code festhalten und den Schleifeninhalt als Prozedur oder direkt Zeile für Zeile übergeben?

Delphi-Quellcode:

for i := 0 to 99 do
 begin
  1
  2
  3
 end;

for i := 0 to 99 do
 begin
  A
  B
  C
 end;

In obigen Falle (Beispiel) würde ich mir diese doppelte Schreibarbeit des Schleifenkopfes gerne ersparen und stattdessen so was hier schreiben

Delphi-Quellcode:

ForTemplate0To99.Do(
 procedure
  begin
   A
   B
   C
  end);
);

oder

ForTemplate0To99.Do(MeineProcedur;);

[Zacherl]

Ja, das geht über Anonyme Methoden.

[Bernhard Geyer]

Sicherlich gibt es Möglichkeiten. Aber ob sich das Lohnt 3 Zeilen einer sehr verständlichen schleife durch sowas wie Methodenparameter und anonyme Methoden zu ersetzen lohnt?

Wenn es sich nicht nur im eine einfache Schleife sonder mehr handeln würde (Langläufer mit aktualisierung GUI und Abbrechbarkeit, dann ja.

[LTE5]

Zitat:

Aber ob sich das Lohnt 3 Zeilen einer sehr verständlichen schleife durch sowas wie Methodenparameter und anonyme Methoden zu ersetzen lohnt?

Das war doch nur ein Beispiel ;)

[Bernhard Geyer]

Zitat:

Zitat von LTE5 (Beitrag 1390095)

Zitat:

Aber ob sich das Lohnt 3 Zeilen einer sehr verständlichen schleife durch sowas wie Methodenparameter und anonyme Methoden zu ersetzen lohnt?

Das war doch nur ein Beispiel ;)

Die beiden Mitforisten haben dir ja schon weiterführende Links bzw. Beispielcode gegeben.

[Delphi.Narium]

Unter Delphi 7 kann man das so machen:

Delphi-Quellcode:

Type 
  // Einen Typen festlegen, der den Aufrufparametern der zu "verschleifenden" Funktionen entspricht.
  tFormel = function(a : Integer; b : Integer) : LongInt;
  // Proceduren würden auch gehen.
  tProzeduren = Procedure(a : Integer; b : Integer);

function EineFormel(a : Integer; b : Integer) : LongInt;
begin
  Result := a * b;
end;

function NochEineFormel(a : Integer; b : Integer) : LongInt;
begin
  Result := a + b;
end;

function For_A_To_B_Do(AForVon : Integer; AForBis : Integer; AFormel : TFormel; aParameter : Integer; bParameter : Integer) : Integer;
var
  i : Integer;
begin
  Result := 0;
  for i := AForVon to AForBis do Result := Result + AFormel(aParameter, bParameter);
end;

function machmalwas : Integer;
var
  Formel : TFormel;
begin
  Formel := EineFormel;
  Result := For_A_To_B_Do(1,100,Formel,100,200);
  Formel := NochEineFormel;
  Result := Result div For_A_To_B_Do(1,100,Formel,100,200);
end;

Und das ist noch nichteinmal kryptisch.

[LTE5]

Für Tokyo habe ich das jetzt so gemacht

Delphi-Quellcode:

type
 TProcedureParameter = reference to procedure(i: Integer);

implementation

procedure ForLoop(Proc: TProcedureParameter);
var
 i: Integer;
begin
 for i := 0 to 3 do
  Proc(i);
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
 ForLoop(
   procedure(i: Integer)
  begin
   ShowMessage(i.ToString);
  end);
end;

X wird 3x aufgerufen.
Wenn ich jetzt etwas am Schleifenkopf ändere, muss ich es nur noch an einer Stelle tun und nicht mehr an 100.

=> Habe erfolgreich resigniert :thumb:
klappt nicht so wie ich will. Denn abbrechen kann man die Schleife dann scheinbar nicht mehr.

[Jumpy]

Kann man das nicht als Funktion schreiben, die False zurück gibt, wenn abgebrochen werden soll?

for i := 0 to 3 do
if not Proc(i) then break;

[LTE5]

Das ist die Frage. Das übersteigt aber meine Fähigkeiten :oops:

[SProske]

Delphi-Quellcode:

implementation

procedure ForLoop(Func: TFunc<Integer, Boolean>);
var
  i: Integer;
begin
  for i := 0 to 3 do
    if not Func(i) then
      Break;
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
  ForLoop(
    function(i: Integer): Boolean
    begin
      ShowMessage(i.ToString);
      Result := I <= 1;
      //oder vllt eher
      Result := I <= 2;
      if Result then
        ShowMessage(i.ToString);
    end);
end;

[uligerhardt]

Zitat:

Zitat von LTE5 (Beitrag 1390110)

X wird 3x aufgerufen.
Wenn ich jetzt etwas am Schleifenkopf ändere, muss ich es nur noch an einer Stelle tun und nicht mehr an 100.

=> Habe erfolgreich resigniert :thumb:
klappt nicht so wie ich will. Denn abbrechen kann man die Schleife dann scheinbar nicht mehr.

Geht's dir wirklich nur um die Anzahl??? Dann nimm bittebittebitte eine Konstante! :pale:

Delphi-Quellcode:

const
  cLoopCount = 4;

for i := 0 to cLoopCount - 1 do // oder for i := 1 to cLoopCount do
  ...

[LTE5]

Zitat:

Zitat von LTE5 (Beitrag 1390095)

Zitat:

Aber ob sich das Lohnt 3 Zeilen einer sehr verständlichen schleife durch sowas wie Methodenparameter und anonyme Methoden zu ersetzen lohnt?

Das war doch nur ein Beispiel ;)

Ich zitiere mich noch einmal :P

[uligerhardt]

Zitat:

Zitat von LTE5 (Beitrag 1390121)

Zitat:

Zitat von LTE5 (Beitrag 1390095)

Zitat:

Aber ob sich das Lohnt 3 Zeilen einer sehr verständlichen schleife durch sowas wie Methodenparameter und anonyme Methoden zu ersetzen lohnt?

Das war doch nur ein Beispiel ;)

Ich zitiere mich noch einmal :P

Was willst du denn variieren können? Wie man sieht, kann das die Lösungsmöglichkeiten stark beeinflussen.

[QuickAndDirty]

Ich glaube er wünscht sich so einen Stil wie Javascript.
Wo man massive Dinge wie höhere Funktionen und bindings als Funktionsparameter verwenden kann.

[LTE5]

Nee. Ich benutze an sehr vielen Stellen im Programm immer wieder denselben Schleifenkopf und vor diesem Schleifenkopf noch eine weitere if-Abfrage.

Etwa so

Delphi-Quellcode:

{ 1 } if Liste.Count > 0 then
  begin
{ 2 }   for i := 0 to Liste.Count - 1 do
   begin
    DieEigentlicheArbeit;
   end;
 end;

Durch das Auslagern des Schleifenkopfes und DieEigentlicheArbeit (das kann alles sein) als Prozedurparameter habe ich { 1 } und { 2 } jetzt nur noch an einer einzigen Stelle.

Delphi-Quellcode:

procedure TForm1.ForLoopList(Func: TFunc<Integer, Boolean>);
var
 i: Integer;
begin
 if Liste.Count = 0 then
  Exit;

 for i := 0 to Liste.Count - 1 do
  begin
   if Func(i) then
    Break;
  end;
end;

ForLoopList(
 function(i: Integer): Boolean
  begin
   Result := DieEigentlicheArbeit;
  end);

Was ich jedoch noch nicht so richtig verstehe, ist die Definition von TFunc. Warum <Integer, Boolean>?

[Bernhard Geyer]

Du weißt aber schon das der erste Teil mit "if Liste.Count > 0" unnötig ist wenn nur die for-Schleife folgt.:gruebel:

[LTE5]

Sähe das sonst aber nicht so aus?

Delphi-Quellcode:

FÜR i = 0 BIS -1 DANN

Weil Liste.Count -1 bedeutet ja 0-1 = -1?

Zitat:

if Liste.Count > 0

Warum denn > 0? Ich prüfe im neuen Code auf = 0.

[DeddyH]

Zitat:

Zitat von LTE5 (Beitrag 1390190)

Was ich jedoch noch nicht so richtig verstehe, ist die Definition von TFunc. Warum <Integer, Boolean>?

http://docwiki.embarcadero.com/Libra...SysUtils.TFunc

[edit] Wenn bei der For-Schleife der Anfangswert nicht mindestens genauso groß wie der Endwert ist, wird sie gar nicht erst durchlaufen. [/edit]

[Bernhard Geyer]

Zitat:

Zitat von LTE5 (Beitrag 1390192)

Sähe das sonst aber nicht so aus?

Delphi-Quellcode:

FÜR i = 0 BIS -1 DANN

Weil Liste.Count -1 bedeutet ja 0-1 = -1?

ja und? D.h. er geht nie in die Schleife.

Zitat:

Zitat von LTE5 (Beitrag 1390192)

Zitat:

if Liste.Count > 0

Warum denn > 0? Ich prüfe im neuen Code auf = 0.

Also ich sehe da eine Zeile:

Delphi-Quellcode:

{ 1 } if Liste.Count > 0 then

[Delphi.Narium]

Anderer Ansatz: 'nen Nachfahren von List (was auch immer das jetzt genau ist) bauen. Für 'ne TStringList sinngemäß sowas (mit Delphi 7 probiert und funktioniert):

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  tLoopFunc = Function(AString : String) : Boolean;

type
  tForLoopList = class(TStringList)
  private
    { Private-Deklarationen }
  public
    function DoLoop(AProc : tLoopFunc) : Boolean;
  end;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function DieEigentlicheArbeit(AString : String) : Boolean;
begin
  if aString = 'x' then begin
    // mach noch was ...
    Result := True;
  end else Result := False;
end;

function DieAndereArbeit(AString : String) : Boolean;
begin
  if aString = 'x' then begin
    // mach noch was ....
    ShowMessage('Eine Zeile mit x');
    Result := True;
  end else Result := False;
end;

function tForLoopList.DoLoop(AProc : TLoopFunc) : Boolean;
var
  i : Integer;
begin
  Result := False;
  if Not Assigned(AProc) then Exit;
  for i := 0 to Self.Count - 1 do begin
    Result := AProc(Self[i]);
    if Result then Break;
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  sl : tForLoopList;
begin
  sl := tForLoopList.Create;
  // irgendwie jetzt für Inhalt in sl sorgen.
  // sl.LoadFromFile('x.txt');
  sl.Add('x');
  case sl.DoLoop(DieEigentlicheArbeit) of
    true  : sl.DoLoop(DieAndereArbeit);
    false : ShowMessage('war nix');
  end;
  // Ergbenis eventuell abspeichern?
  // sl.SaveToFile('x.txt');
  sl.Free;
end;

end.

[LTE5]

Das mit dem Nachfahren wird nix denn DieEigentlicheArbeit ist immer eine andere und dafür Prozeduren zu erstellen lohnt sich nicht.

[Delphi.Narium]

Und hier

Delphi-Quellcode:

procedure TForm1.Button3Click(Sender: TObject);
begin
 ForLoop(
   procedure(i: Integer)
  begin
   ShowMessage(i.ToString);
  end);
end;

hast Du innerhalb von ForLoop( ... ); keine Procedure geschrieben?

Es ist demnach also ein wesentlicher Unterschied, ob man obiges schreibt oder sinngemäß

Delphi-Quellcode:

procedure Machwas(i: Integer);
begin
 ShowMessage(i.ToString);
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
 List.ForLoop(Machwas);
end;

Bei so 'nem Einzeiler mag das ja nicht viel ausmachen, wenn Machwas (und die weiteren Prozeduren) aber etwas komplexer werden, könnte die Methode mit dem Nachfahren auch irgendwann mal deutlich übersichtlicher werden. (Und ist ggfls. auch noch in anderen Programmen einfach mal so eben verwendbar.)

[LTE5]

Ich finde es durch den Nachfahren deutlich unübersichtlicher.
Ich brauche ja keinen Nachfahren sondern einfach nur den Prozedurkopf an einer Stelle im Code statt an x verschiedenen.
Und genau das habe ich jetzt.

[uligerhardt]

Zitat:

Zitat von LTE5 (Beitrag 1390192)

Sähe das sonst aber nicht so aus?

Delphi-Quellcode:

FÜR i = 0 BIS -1 DANN

Weil Liste.Count -1 bedeutet ja 0-1 = -1?

Selbst wenn das ein Problem wäre (was es ja nicht ist), würde die cLoopCount-Variante auch dein if mit abdecken.

Immer noch kein Bedarf für schwerer lesbaren und vermutlich deutlich langsameren Code. :mrgreen:
(Mal abgesehen davon traue ich den derzeitigen Profis bei Embarcadero zu, dass sie bei neueren Sprachfeatures einige Überraschungen für dich einbauen. :twisted:)

[LTE5]

Zitat:

Immer noch kein Bedarf für schwerer lesbaren und vermutlich deutlich langsameren Code.
(Mal abgesehen davon traue ich den derzeitigen Profis bei Embarcadero zu, dass sie bei neueren Sprachfeatures einige Überraschungen für dich einbauen. )

Was genau meinst du mit beiden Sätzen?

[HolgerX]

Hmm..

Ich würd es so machen (old school, D6)

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    function DoWas(AStrings : TStrings; AIndex : integer):boolean;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}
type
  TExecuteStrings = function(AStrings : TStrings; AIndex : integer):boolean of Object;
  TExecuteList = function(AList : TList; AIndex : integer):boolean of Object;

procedure ExecuteList(AStrings : TStrings; AFunc : TExecuteStrings);overload;
var
  i : integer;
begin
  for i := 0 to AStrings.Count-1 do
    if AFunc(AStrings,i) then break;
end;

procedure ExecuteList(AList : TList; AFunc : TExecuteList);overload;
var
  i : integer;
begin
  for i := 0 to AList.Count-1 do
    if AFunc(AList,i) then break;
end;


procedure TForm1.Button1Click(Sender: TObject);
var
  s : TStringList;
begin
  s := TStringList.Create;
  try
    s.Add('Test1');
    s.Add('Test2');
    s.Add('Test3');
    ExecuteList(s, DoWas);
  finally
    s.Free;
  end;
end;

function TForm1.DoWas(AStrings: TStrings; AIndex: integer): boolean;
begin
  ShowMessage(AStrings[AIndex]);
  Result := AStrings[AIndex] = 'Test2';
end;

Da ich der Übergebenden Funktion auch die Liste selber mitgebe (nicht nur den Index), kann die Funktion direkt mit der richtigen Liste arbeiten.

Im Beispiel oben ist nur zwischen TList und TStrings unterschieden.

Wenn Du vorhast (wie z.B. in Lua möglich) eine Funktion zu übergeben, welche unterschiedliche Anzahl/Typen an Parameter hat, dann dürfte dies schwierig werden, vor allem, da deine Loop-Funktion nicht wüste, was an welcher Stelle im Funktionsaufruf übergeben werden muss.

[uligerhardt]

Zitat:

Zitat von LTE5 (Beitrag 1390244)

Was genau meinst du mit beiden Sätzen?

Upps, ist wieder der Poet mit mir durchgegangen. :mrgreen:

Ich denke, die Lösung mit anonymen Methoden ist schlechter lesbar und weniger verständlich als z.B. die banale Konstantenidee. Außerdem habe ich das Bauchgefühl, dass sie auch langsamer ist. Das wäre aber vielleicht in der Praxis eh irrelevant.

Der Satz in Klammern bezieht sich darauf, dass die Kompetenz bei Embas Entwicklern früher besser war, was man so mitkriegt. Drum hab ich beim Benutzen neuerer Features immer etwas Angst. :stupid:

[LTE5]

Zitat:

Ich denke, die Lösung mit anonymen Methoden ist schlechter lesbar und weniger verständlich als z.B. die banale Konstantenidee. Außerdem habe ich das Bauchgefühl, dass sie auch langsamer ist. Das wäre aber vielleicht in der Praxis eh irrelevant.

Ich müsste das schon mehrere tausend male aufrufen, um überhaupt einen messbaren aber nicht spürbaren Effekt zu erhalten.

Ob schlechter lesbar oder nicht ist mir im Prinzip Schnuppe. Denn der Code wird von mir gelesen wird nicht geteilt.

[Mavarik]

Zitat:

Zitat von LTE5 (Beitrag 1390267)

Ob schlechter lesbar oder nicht ist mir im Prinzip Schnuppe. Denn der Code wird von mir gelesen wird nicht geteilt.

Immer gut junger Padawan, wenn man nach ein paar Monaten sich seinen eignen Code ansieht und nicht mehr versteht, um was es eigentlich ging.

Aber Du bist ja nicht mein Schüler...

[LTE5]

Dann ließt man sich 5 Minuten ein und alles ist gut.

[uligerhardt]

Zitat:

Zitat von LTE5 (Beitrag 1390272)

Dann ließt man sich 5 Minuten ein und alles ist gut.

Von mir aus. Aber: Warum?

Wenn du zum Lernen mit neuen Sachen rumspielen, ist das gut, aber als Lösung für dein Problem (wie ich es verstanden habe)???

[LTE5]

Es funktioniert einwandfrei und die Nutzung ist sehr einfach.
Ich finde es gut lesbar. Man muss dem Kind nur einen guten Namen geben.

[Mavarik]

Zitat:

Zitat von LTE5 (Beitrag 1390272)

Dann ließt man sich 5 Minuten ein und alles ist gut.

Ja ne is klar...

Du hast noch nie ein größeres Programm geschrieben, oder?