Array [1..5] of Function

[Glühwürmchen]

Ist es unter Delphi 7 möglich ein Arry zu definieren, dessen Elemente aufrufbare Functions oder Procedures sind?
Wenn ja, was ist nötig, damit ich das Konsrtrukt zum Laufen kriege?

Hintergrund der Frage:
Ich habe eine Win32-Anwendung, mit einigen Formularen, mit jeder Menge Edit-Felder.
Aber wann immer ich in ein Editfeld hinein klicke geht der selbe (und einzige) Dialog auf, in dem der Wert des Editfeldes geändert werden kann.
Hierzu übergebe ich an die FormEditPopup alle Informationen, die nötig sind, damit die Editierung korrekt abläuft:

Delphi-Quellcode:

class function Execute(const aFensterbeschriftung: String; const aZellenwertAlt, aBeschreibung: String;
                        var vZellenwertNeu: String; var vModalResult: TModalResult;
                        const aChoiceValues: TStringList; const aControlIsTextEdit: Boolean = TRUE)
                  : TFormEditPopup;

Nun ist es jedoch so, dass die geänderten Werte in eine DB sollen und dort nicht unbedingt alle Werte sinnvoll sind.
Folglich wäre eine Prüfung des neuen abzuspeichernden Wertes nicht schlecht.

Meine Idee:
Ich lege für jede Zelle, bei der eine Prüfung erforderlich ist, eine Prüfroutine ("function Prüfe(...): Boolean;") an.
Damit ich auf diese Routinen bequem zugreifen kann, und nicht ellenlange Abfragelisten einführen muss,
möchte ich die Prüfungen gerne in einem Array organisieren.

Und warum so kompliziert?
"Warum überprüfst Du den Wert nicht in der Unit, die das TFormEditPopup.Execute aufruft?"
--> Weil ich mich an die Vorgabe halten muss, dass der geänderte Wert von "TFormEditPopup" in die DB geschrieben werden muss und nicht vom aufrufenden Fenster, weil sich nämlich die Daten mitunter recht schnell ändern und das aufrufende Fenster seinerseits mehrfach aufgerufen werden darf, das "TFormEditPopup" aber immer nur einmal und außerdem noch Modal angezeigt wird!
--> Kurz: Weil das "TFormEditPopup" gewährleistet, dass in den Daten kein Versionschaos entsteht.

[implementation]

Kein Problem:

Delphi-Quellcode:

type
  TExecutefunction = function(const aFensterbeschriftung: String; const aZellenwertAlt, aBeschreibung: String;
                        var vZellenwertNeu: String; var vModalResult: TModalResult;
                        const aChoiceValues: TStringList; const aControlIsTextEdit: Boolean = TRUE) : TFormEditPopup of object;
  TExecutefunctions = array[1..5] of TExecutefunction;

[Glühwürmchen]

Cool!
Vielen Dank für die schnelle Antwort. Das probiere ich sofort aus!

[Glühwürmchen]

Ok,
sieht so einfach aus, aber die Übertragung gelingt mir nicht.

So habe ich es versucht:

Delphi-Quellcode:

11  type
12    TValidatefunction = function(const aNeuerWert: String): Boolean;
13      function PosDstExists(const aPosDst: String): Boolean;
14
15    TValidatefunctions = array[1..1] of TValidatefunction;
16
17  type
18    TPrjFrmEditPopupBase = class(TPrjFrmEditBase)
19      cxLabelBeschreibung: TcxLabel;
...

Die erste ValidierungsFunktion ist:

Delphi-Quellcode:

310  function PosDstExists(const aPosDst: String): Boolean;
311  var
312    tbl: TClass_TBLPOSITION;
313
314  begin
315    result := TRUE;
...

Ich dachte mir, wo ein Array ist, braucht es auch eine Initialisierung:

Delphi-Quellcode:

333  initialization
334    TValidatefunctions[1] := PosDstExists;
335  end.

So unsicher wie ich mich dabei fühle, ist es kein Wunder, dass mir der Compiler das gleich mal um die Ohren schlägt:
[Fehler] PrjFormEditPopupBase.pas(15): Unbekannte Anweisung: 'TValidatefunctions'
[Fehler] PrjFormEditPopupBase.pas(15): Deklaration erwartet, aber '=' gefunden
[Fehler] PrjFormEditPopupBase.pas(334): Undefinierter Bezeichner: 'TValidatefunctions'
[Fehler] PrjFormEditPopupBase.pas(334): Ausdruck erwartet, aber 'CONST' gefunden
[Fehler] PrjFormEditPopupBase.pas(334): '=' erwartet, aber ')' gefunden
[Fehler] PrjFormEditPopupBase.pas(335): Inkompatible Typen: 'String' und 'Boolean'

[himitsu]

Du mußt dich Mal entscheiden:
Mit "of object" kann man der Variable eine Methode (function) oder Klassen-Methode (class function) zuweisen, welche in Klasse enthalten ist.
Willst du eine normale Prozedur/Funktion zuweisen (so wie dein PosDstExists), dann ohne das "of object".

Zitat:

TValidatefunctions[1] := ...

Und das TValidatefunctions ist ein Typ, aber du willst doch eigentlich eine Variable haben.

[Glühwürmchen]

Ok,
erst mal Danke, für die Antwort - auch wenn ich sie momentan nur teilweise verstehe.

Hm, entschieden habe ich mich schon. Nur offenbar, fehlt es mir am Durchblick, Eure Antworten richtig umzusetzen
oder ich bin zu müde dafür.

Wie dem auch sei, ich sehe mir das morgen früh noch mal an und melde mich wieder.

Vielen Dank nochmal.
Gute N8.

[himitsu]

Nja, erstmal mußt du wissen für was du einen Funktions-Zeiger brauchst.

Delphi-Quellcode:

procedure EineProzedur{...};

type
  TEineKlasse = class
    procedure EineMethode{...};
    class procedure EineKlassenMethode{...};
  end;

begin
  Syncronize(nil, 
    procedure{...}  // EineAnonymeMethode ... Anonym und darum auch ohne Namen ;)
    begin
      ShowMessage('Hallo');
    end);
end;

Und danach entscheidet sich welcher Zeigertyp sich am Besten eignet.

Delphi-Quellcode:

type
  EinProzedurZeiger = procedure{...}; // Prozeduren
  EinMethodenZeiger = procedure{...} of class; // Methoden oder Klassen-Methoden
  EinAnonymerZeiger = reference to procedure{...}; // alles (aber wenn es nur um Prozeduren ODER Methoden geht, dann isses ein bissl viel Overhead)

[implementation]

Hinweis: Es geht um Delphi 7, da gab es weder Anonyme Methoden, noch das Reference-To-Konstrukt.

[himitsu]

Ich hab ihm ja nicht umsonst vorher schonmal gezeigt, wie es (nur) für Prozeduren oder Methoden geht.
Das war jetzt nur nochma ein Überblick über Alles, was "aktuell" möglich ist (abgesehn von den bösen Zeigergeschichten und der RTTI).

[Glühwürmchen]

Also vielen Dank für Eure Antworten!
Aufgrund des Zeitdrucks, der beim Projektende immer auftritt und meiner Verständnisschwierigkeiten habe ich das Problem schließlich anders gelöst.

Aber sobald ich wieder etwas Luft habe, lese ich das hier noch mal in Ruhe durch und versuche es nachzuvollziehen.