Wie kann ein Zeiger auf eine Funktion als Paramater übergeben werden?

[DeddyH]

Im Profil steht Delphi 5, da kann man die Hälfte Deiner Ausführungen wieder vergessen (Klassenmethoden, anonyme Methoden, ...) :tongue:

[himitsu]

Zitat:

Zitat von DeddyH (Beitrag 1064320)

Im Profil steht Delphi 5,

Ja, hab ich gesehn.

Man kann ihm ja auch mal was Neueres schmackhaft machen?

Und dann gibt es auch sehr Viele, mit anderen Delphi-Versionen (und sogar einige Fremdgänger ohne Delphi :stupid: ) und vorallem für die, mit neueren Versionen, kann man doch auch mal gleich was mit sagen.
> Falls sie hier mitlesen, entdecken sie vierleicht auch noch was für sich. :angel:

[DeddyH]

[OT]

Zitat:

Zitat von himitsu (Beitrag 1064323)

Man kann ihm ja auch mal was Neueres schmackhaft machen?

Bist Du auf Provision aus? :twisted: [/OT]

[himitsu]

Dafür kann man Geld bekommen? :shock:

Nja, aktuell bekomm ich wieder mal mit, wie sehr ich einige neuere Features mag.
Die Generics sind zwar teilweise total blöde und nicht benutzbar, aber vorallem die generische TList<> ist was extrem Feines.
Und auch die Klassenvariablen seit D2006/TDE sind schon praktisch, im Kampf gegen die bösen globalen Variablen.


nochmal @Topic:
Also, wie gesagt, für diesen Fall wäre TTest2 die Lösung.

[FriendOfDelphi]

Ich habe Delphi 5 und möchte dies auch erstmal weiter verwenden...
Was gilt denn von dem Gesagten für Delphi 5?
Ich kann euch noch nicht so richtig folgen.

Ich habe eine Unit in dem das Form gemacht wird. Hier soll auch die Funktion deklariert und definiert werden, die dem Objekt beim Erstellen mitgegeben werden soll.
Der Konstruktor und alle weiteren Methoden sind in einer zweiten Unit.

[DeddyH]

Du willst doch eine Routine/Methode als Parameter deklarieren, ist das soweit richtig? Wenn ja, dann musst Du diese nur typisieren, dann geht das ohne Probleme. Der einzige Unterschied zwischen einfacher Routine und Methode ist der, dass eine Methode zu einer Klasse gehört, weshalb man bei der Typisierung dann "of object" dahinter schreiben muss (und dann natürlich auch eine Klasse braucht, die ein entsprechendes Methodenfeld besitzt).

[Bummi]

Ich hab Dir mal ein Beispiel gebastelt, der Übersicht halber alles in einer Unit

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TBeispiel=Procedure(Sender:TObject) of object;

  TMyClass=Class(TButton)
    Private
      FMethode:TBeispiel;
    public
    Constructor Create(AOwner:TComponent;Methode:TBeispiel);
  End;


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

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TMyClass }

constructor TMyClass.Create(AOwner: TComponent; Methode: TBeispiel);
begin
  inherited Create(AOwner);
  FMethode := Methode;

  //TEST
  Tag := 100;
  if Assigned(FMethode) then FMethode(Self);
  //ENDE TEST
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Showmessage(IntToStr(TComponent(Sender).Tag));
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  With TMyClass.Create(Self,Button1Click) do
    begin
      Parent := self;
      Caption := 'Neuer Button';
    end;
end;

end.

[FriendOfDelphi]

Danke für den Beispielcode.
Ich habe diesen noch etwas verändert und vereinfacht, um mir die eigentliche Aufgabe noch etwas mehr zu verdeutlichen und zu überprüfen, ob ich das richtig verstanden habe:

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TBeispiel=procedure() of object; //Typdefinition eigener Typ "TBeispiel"

  TBeispielKlasse=Class(TForm)
    Private
      FMethode:TBeispiel; //Deklaration Feld "FMethode" vom eigenen Typ "TBeispiel"
    Public
      constructor Create(Methode:TBeispiel); //Deklaration Konstruktor mit Methode als Übergabeparameter vom eigenen Typ "TBeispiel"
  end;

  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    procedure Prozedur_1();
    procedure Prozedur_2();
  end;

var
  Form1: TForm1;
  BeispielObjekt_1: TBeispielKlasse;
  BeispielObjekt_2: TBeispielKlasse;

implementation

{$R *.DFM}

constructor TBeispielKlasse.Create(Methode:TBeispiel);
begin
  FMethode:=Methode;
end;


procedure TForm1.Prozedur_1();
begin
  ShowMessage('Prozedur_1');
end;


procedure TForm1.Prozedur_2();
begin
  ShowMessage('Prozedur_2');
end;


procedure TForm1.FormCreate(Sender: TObject);
begin
  BeispielObjekt_1:=TBeispielKlasse.Create(Prozedur_1);
  BeispielObjekt_1.FMethode;
  BeispielObjekt_2:=TBeispielKlasse.Create(Prozedur_2);
  BeispielObjekt_2.FMethode;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  BeispielObjekt_1.Free;
  BeispielObjekt_2.Free;
end;

end.

1.) Zuerst wird ein eigener Datentyp definiert:

Delphi-Quellcode:

TBeispiel=procedure() of object;

. Mit diesem kann man nun Variablen deklarieren, die eine Methode darstellen.
2.) Als nächstes wird dann eine Variable/ein Feld von diesem Typ (

Delphi-Quellcode:

FMethode:TBeispiel;

) deklariert.
3.) Dann erfolgt die Deklaration des Konstruktors, dem ein Parameter von ebenfalls diesem Typen (

Delphi-Quellcode:

FMethode:TBeispiel;

) übergeben werden muss. Innerhalb des Konstruktors wird zur Programmlaufzeit der Klassenmethode

Delphi-Quellcode:

FMethode

, die als Parameter übergebene Methode, der Klasse übergeben.
4.) Anschließend ist diese dann Teil der Klasse und und steht innerhalb der Klasse zur Verfügung.

Gut zu sehen ist das, wenn das Formluar erzeugt wird.
Hier werden die beiden Objekte erzeugt und diesen jeweils eine eigene Methode zugewiesen.
Ich hoffe, dass ich das so richtig verstanden und wiedergegeben habe.
Ansonsten können die Profis ja nochmal etwas dazu sagen.

[DeddyH]

Genau richtig. Allerdings würde ich persönlich die Methode nicht im Konstruktor übergeben lassen, sondern als Property deklarieren, damit sie sich im weiteren Programmverlauf ggf. ändern lässt, aber das hat mit der Problematik jetzt nichts zu tun.

[FriendOfDelphi]

Zitat:

Zitat von DeddyH (Beitrag 1064848)

Genau richtig. Allerdings würde ich persönlich die Methode nicht im Konstruktor übergeben lassen, sondern als Property deklarieren, damit sie sich im weiteren Programmverlauf ggf. ändern lässt, aber das hat mit der Problematik jetzt nichts zu tun.

Dafür wären dann die folgenden Änderungen an obigen Quellcode notwendig:

Delphi-Quellcode:

[...schnipp...]

    Public
//      constructor Create(Methode:TBeispiel); //Deklaration Konstruktor mit Methode als Übergabeparameter vom eigenen Typ "TBeispiel"
      constructor Create(); //Deklaration Konstruktor ohne Übergabeparameter
      procedure SetzeBeispielEigenschaft(mMethode: TBeispiel); //Methode für das Setzen der Property/Eigenschaft vom eigenen Typ "TBeispiel"
      property BeispielEigenschaft: TBeispiel read FMethode write SetzeBeispielEigenschaft; //Property/Eigenschaft vom eigenen Typ "TBeispiel"

[...schnipp...]

//constructor TBeispielKlasse.Create(Methode:TBeispiel);
constructor TBeispielKlasse.Create();
begin
  //mache irgendwas...
  FMethode:=nil;
end;

[...schnipp...]

procedure TForm1.FormCreate(Sender: TObject);
begin
//  BeispielObjekt_1:=TBeispielKlasse.Create(Prozedur_1);
  BeispielObjekt_1:=TBeispielKlasse.Create();
  BeispielObjekt_1.SetzeBeispielEigenschaft(Prozedur_1);
  BeispielObjekt_1.FMethode;
//  BeispielObjekt_2:=TBeispielKlasse.Create(Prozedur_2);
  BeispielObjekt_2:=TBeispielKlasse.Create();
  BeispielObjekt_2.SetzeBeispielEigenschaft(Prozedur_2);
  BeispielObjekt_2.FMethode;
end;

[...schnipp...]