Funktionen als Parameter übergeben

[Alexander Roth]

Hallo,

also die Funktionen in Delphi eignen sich ideal um sie als Mathematik-Funktionen zu nutzen. Also Real übergeben und Real kommt raus.
Da ich unteranderem viele von diesen Delphi=Mathe-Fukntionen habe, und ich mit denen die gleichen Operationen mit ihnen machen will würde sich so was anbieten:

Delphi-Quellcode:

function f(x:real):real;  //Die Mathematik-Funktion 

function Nullstelle(funktion:Tfunction):real;  //die Fukntion der ich die Fukntion übergebe

Also ich hoffe das ist verständlich.
Wie kann man so was realisieren?


PS: Falls die Frage kommt --> Nein, ich kann die Funktion f nicht in einem anderen Format speichern, da die Funktion f mit sehr vielen Schritten berechnet wird (mit Bedingungen), und ist streng genommen eine sehr komplexe (rationale) zusammengesetzte Funktion.

Gruß Alexander


Edit: Immer diese Rechtschreibfehler

[sniper_w]

Delphi-Quellcode:

type
tmyFunction = function (x:real):real;

function s_function( theFunc: TmyFunction ):Real;
begin
  Result := theFunc( 5 );
end;

[himitsu]

Delphi-Quellcode:

Type TMathFunc = Function(x: Real): Real;

Function f(x: Real): Real; 

Function Nullstelle(Funktion: TMathFunc): Real;
  Begin
    Result := Funktion(123.456);
  End;



x := Nullstelle(@f);

[edit]
i wünscht mir 'ne RedBox o.O

[Alexander Roth]

Jo danke also compilieren tut er es.

Danke

Tschüss

Alexander

[Der_Unwissende]

Hi,
ich möchte hier nur kurz noch den OOP Ansatz der Vollständigkeit halber zugeben:
Du kannst so was natürlich auch immer in einem Interface/einer abstrakten Klasse einführen und dann verwenden:

Delphi-Quellcode:

type
  TAbstractComputer = class(TObject)
    public
      function compute(x : Real) : Real; virtual; abstract;
  end; 

  TConcreteComputer = class(TVorfahrTyp)
    public 
      function compute(x : Real) : Real; override; // hier natürlich dein Implementierung
  end;

Ja, dann kannst du später einfach einen Aufruf mit einem beliebigen Nachfahren starten

Delphi-Quellcode:

procedure doFoo(const instance : TAbstractComputer);
begin
  if assinged(instance) then
  begin
    instance.compute(<Das Argument>);
  end;
end;

Das ganze entspricht dann einfach nur dem Objektorientierten Ansatz (den man überall dort verwenden müsste, wo es schon keine Funktionszeiger gibt). Ist sogar ein Designpattern (wie gesagt der Vollständigkeit halber)

Gruß Der Unwissende

[Alexander Roth]

Entschuldigung dass ich so spät antworte.

Also ein bisschen erweiterte Situation:
Ich habe die Klassen

Delphi-Quellcode:

    TSonnenstandsFunktion=function(BG,LG:real; time:real;  day,month:byte; year:integer):real;

    TSonne = class
    public
      function getalpha(BG,LG:real; time:real;  day,month:byte; year:integer):real;
      function getbeta(BG,LG:real; time:real;  day,month:byte; year:integer):real;

und die Funktion

Delphi-Quellcode:

function NullStelle(Funktion:TSonnenstandsFunktion):real;
begin
  result:=Funktion(ds.BG,ds.LG,ds.hour,ds.day,ds.month,ds.year);
end;

die ich zu Testzwecken nur mit beispielwerten füttere anstadt die Nullstelle auszurechnen.

Die Variable:
  Sonne:TSonne; Wie übergebe ich die Methode getalpha oder getbeta der Variable Sonne an die Funktion Nullstelle?
So klappt es natürlich nicht:
  showmessage(floattostr(NullStelle(@Tsonne.getbeta))); und so compiliert er es leider nicht:
  showmessage(floattostr(NullStelle(@sonne.getbeta)));

[Der_Unwissende]

Hi,
es ist ein wichtiger Unterschied ob du eine Funktion aus einer Unit heraus übergeben willst, oder aus einem Objekt. Bei einer Unit liegt die Funktion statisch immer an einer Stelle und alles klappt so, wie du es hier stehen hast.
Bei einer Funktion eines Objekts, liegt die Funktion für jedes Objekt (jede Instanz einer Klasse) anders. Deshalb musst du einen Methodenzeiger vom Typ
function(...) : real of Object verwenden (also ein of Object ranhängen).

Gruß Der Unwissende

[Alexander Roth]

Es klappt!!!

Riesen Dank.



PS:
Hinweis an die Leser : Keinen Pointer auf die Methode übergeben, sondern direkt
x := Nullstelle(sonne.getbeta);
PPS: @Der_Unwissende: Willst nicht vielleicht das Un von Der_Unwissende streichen?