Übergabeparameter verfälscht bei Aufruf einer Funktion

[Arakis]

Hi, ich habe folgendes Problem: Wenn ich eine Funktion per Funktionszeiger aufrufe, sind die Übergabeparameter irgendwie verfälscht. Ich kann mir das nicht erklären.

Delphi-Quellcode:

{------------------------------------------------------------------------------}
{ TIntegerComparer
{------------------------------------------------------------------------------}
TIntegerComparerFunc = function(x: Integer; y: Integer): Integer;
TIntegerComparer = class
  private
    _ComparerFunc: TIntegerComparerFunc;
    function GetComparerFunc: TIntegerComparerFunc;
    procedure SetComparerFunc(func: TIntegerComparerFunc);
  public
    function Compare(x: Integer; y: Integer): Integer;
    property ComparerFunc: TIntegerComparerFunc read GetComparerFunc write SetComparerFunc;
    function DefaultComparerFunc(x: Integer; y: Integer): Integer;
    Constructor Create;
    Destructor Destroy;  override;
end;

...

{------------------------------------------------------------------------------}
{ TIntegerComparer
{------------------------------------------------------------------------------}
Constructor TIntegerComparer.Create;
Begin
  _ComparerFunc := @TIntegerComparer.DefaultComparerFunc;
End;

{------------------------------------------------------------------------------}
Destructor TIntegerComparer.Destroy;
Begin
  Inherited;
End;

{------------------------------------------------------------------------------}
function TIntegerComparer.GetComparerFunc: TIntegerComparerFunc;
Begin
  result := _ComparerFunc;
End;

{------------------------------------------------------------------------------}
procedure TIntegerComparer.SetComparerFunc(func: TIntegerComparerFunc);
Begin
  _ComparerFunc := func;
End;

{------------------------------------------------------------------------------}
function TIntegerComparer.Compare(x: Integer; y: Integer): Integer;
begin

  if x = y then
    result := 0
  else if (x < y) then
    result := -1
  else
    result := 1;

  //exit;

  if @_ComparerFunc = nil then
    RaiseException('TIntegerComparer.Compare: Keine Vergleichsfunktion festgelegt');
  result := _ComparerFunc(x, y);
end;

{------------------------------------------------------------------------------}
function TIntegerComparer.DefaultComparerFunc(x: Integer; y: Integer): Integer;
begin
  if x = y then
    result := 0
  else if (x < y) then
    result := -1
  else
    result := 1;
end;

In dem Moment, wenn ich in TIntegerComparer.Compare die Funktion _ComparerFunc(x, y) aufrufen, sind in der verlinkten Funktion DefaultComparerFunc die Parameter x und y auf einmal irgendwie anders anders!? Ich habe mal testweise feste Zahlen bei ComparerFunc angegeben, doch irgendwie hat dann y den Wert von x der Vorgänger funktion. Und das übergebene y wird zu x.

Ich peil gar nix mehr

[Muetze1]

Moin!

Ist auch logisch. Du hast als Vergleichsroutine eine normale Routine definiert und weisst ihr durch böse Tricks eine Methode zu. Damit bekommt dein X Wert beim Aufruf die Instanz und der Y Wert den X Wert. Abgesehen davon, das der Stack durcheinander kommt, weil ja der gepushte Y Wert liegen bleibt....

MfG
Muetze1

[Christian Seehase]

Moin Arakis,

Methoden haben noch einen impliziten Parameter, der vor den anderen kommt, nämlich self.
Intern sieht, z.B.,

function TIntegerComparer.DefaultComparerFunc(x: Integer; y: Integer): Integer; so aus:

Code:

function TIntegerComparer.DefaultComparerFunc([color=red]self: TIntegerComparer;[/color]x: Integer; y: Integer): Integer;

[Arakis]

Was muss ich denn da ändern? Ich weiß leider nur unvollständig, wie man mit Funktionszeigern umgeht.

[Muetze1]

Moin!

1. Du hast als Vergleichsprocedure eine Methode:

Delphi-Quellcode:

{------------------------------------------------------------------------------}
{ TIntegerComparer
{------------------------------------------------------------------------------}
TIntegerComparerFunc = function(x: Integer; y: Integer): Integer Of Object;
TIntegerComparer = class
  private
    _ComparerFunc: TIntegerComparerFunc;
    function GetComparerFunc: TIntegerComparerFunc;
    procedure SetComparerFunc(func: TIntegerComparerFunc);
  public
    function Compare(x: Integer; y: Integer): Integer;
    property ComparerFunc: TIntegerComparerFunc read GetComparerFunc write SetComparerFunc;
    function DefaultComparerFunc(x: Integer; y: Integer): Integer;
    Constructor Create;
    Destructor Destroy;  override;
end;

...

{------------------------------------------------------------------------------}
{ TIntegerComparer
{------------------------------------------------------------------------------}
Constructor TIntegerComparer.Create;
Begin
  _ComparerFunc := DefaultComparerFunc;
End;

{------------------------------------------------------------------------------}
Destructor TIntegerComparer.Destroy;
Begin
  Inherited;
End;

{------------------------------------------------------------------------------}
function TIntegerComparer.GetComparerFunc: TIntegerComparerFunc;
Begin
  result := _ComparerFunc;
End;

{------------------------------------------------------------------------------}
procedure TIntegerComparer.SetComparerFunc(func: TIntegerComparerFunc);
Begin
  _ComparerFunc := func;
End;

{------------------------------------------------------------------------------}
function TIntegerComparer.Compare(x: Integer; y: Integer): Integer;
begin

  if x = y then
    result := 0
  else if (x < y) then
    result := -1
  else
    result := 1;

  //exit;

  if Not Assigned(_ComparerFunc) then
    RaiseException('TIntegerComparer.Compare: Keine Vergleichsfunktion festgelegt');
  result := _ComparerFunc(x, y);
end;

{------------------------------------------------------------------------------}
function TIntegerComparer.DefaultComparerFunc(x: Integer; y: Integer): Integer;
begin
  if x = y then
    result := 0
  else if (x < y) then
    result := -1
  else
    result := 1;
end;

Oder
2. eine normale Procedure/Funktion

Delphi-Quellcode:

{------------------------------------------------------------------------------}
{ TIntegerComparer
{------------------------------------------------------------------------------}
TIntegerComparerFunc = function(x: Integer; y: Integer): Integer;
TIntegerComparer = class
  private
    _ComparerFunc: TIntegerComparerFunc;
    function GetComparerFunc: TIntegerComparerFunc;
    procedure SetComparerFunc(func: TIntegerComparerFunc);
  public
    function Compare(x: Integer; y: Integer): Integer;
    property ComparerFunc: TIntegerComparerFunc read GetComparerFunc write SetComparerFunc;
    Constructor Create;
    Destructor Destroy;  override;
end;

...

{------------------------------------------------------------------------------}
function DefaultComparerFunc(x: Integer; y: Integer): Integer;
begin
  if x = y then
    result := 0
  else if (x < y) then
    result := -1
  else
    result := 1;
end;

{------------------------------------------------------------------------------}
{ TIntegerComparer
{------------------------------------------------------------------------------}
Constructor TIntegerComparer.Create;
Begin
  _ComparerFunc := DefaultComparerFunc;
End;

{------------------------------------------------------------------------------}
Destructor TIntegerComparer.Destroy;
Begin
  Inherited;
End;

{------------------------------------------------------------------------------}
function TIntegerComparer.GetComparerFunc: TIntegerComparerFunc;
Begin
  result := _ComparerFunc;
End;

{------------------------------------------------------------------------------}
procedure TIntegerComparer.SetComparerFunc(func: TIntegerComparerFunc);
Begin
  _ComparerFunc := func;
End;

{------------------------------------------------------------------------------}
function TIntegerComparer.Compare(x: Integer; y: Integer): Integer;
begin

  if x = y then
    result := 0
  else if (x < y) then
    result := -1
  else
    result := 1;

  //exit;

  if Not Assigned(_ComparerFunc) then
    RaiseException('TIntegerComparer.Compare: Keine Vergleichsfunktion festgelegt');
  result := _ComparerFunc(x, y);
end;

MfG
Muetze1

[Arakis]

Hm. Also Quelltext2 scheint genau der selbe zu sein wie meine Version. Wo ist denn dort was anders? Und bei Quelltext eins bekomme ich in der Funktion TIntegerComparer.Create die Fehlermeldung "[Error] Larne.pas(1119): Incompatible types: 'regular procedure and method pointer'" wenn ich "_ComparerFunc := DefaultComparerFunc;" statt " _ComparerFunc := @TIntegerComparer.DefaultComparerFunc;" schreibe.

[Muetze1]

Moin!

Zitat von Arakis:

Hm. Also Quelltext2 scheint genau der selbe zu sein wie meine Version. Wo ist denn dort was anders?

DefaultCompare() ist keine Methode mehr (also keine Funktion einer Klasse), sondern eine normale Funktion.

Zitat von Arakis:

Und bei Quelltext eins bekomme ich in der Funktion TIntegerComparer.Create die Fehlermeldung "[Error] Larne.pas(1119): Incompatible types: 'regular procedure and method pointer'" wenn ich "_ComparerFunc := DefaultComparerFunc;" statt " _ComparerFunc := @TIntegerComparer.DefaultComparerFunc;" schreibe.

Dann hast du das wichtige Of Object vergessen bei der Definition von TIntegerComparerFunc...

MfG
Muetze1

[Arakis]

Ach, jetzt habe ich verstanden und es funktioniert auch. Was hat denn dieses "of Object" auf sich?

Also mein spärliches Wissen über Funktionszeiger habe ich hier von: http://www.delphipraxis.net/internal...unktionszeiger

[Sprint]

Delphi-Quellcode:

type
  TIntegerComparerFunc = function(X, Y: Integer): Integer of object;

  TIntegerComparer = class(TObject)
  private
    FComparerFunc: TIntegerComparerFunc;
  public
    function Compare(X, Y: Integer): Integer;
    property CustomCompare: TIntegerComparerFunc read FComparerFunc write FComparerFunc;
  end;

Delphi-Quellcode:

function TIntegerComparer.Compare(X, Y: Integer): Integer;
begin

  if Assigned(FComparerFunc) then
    Result := FComparerFunc(X, Y)
  else
  begin
    if X = Y then
      Result := 0
    else if X < Y then
      Result := -1
    else
      Result := 1;
  end;

end;

oder so: Wenn du lieber Prozeduren anstatt von Methoden bevorzugst.

Delphi-Quellcode:

type
  TIntegerComparerFunc = function(X, Y: Integer): Integer;

  TIntegerComparer = class(TObject)
  private
    FComparerFunc: TIntegerComparerFunc;
  public
    function Compare(X, Y: Integer): Integer;
    property CustomCompare: TIntegerComparerFunc read FComparerFunc write FComparerFunc;
  end;

Delphi-Quellcode:

function TIntegerComparer.Compare(X, Y: Integer): Integer;
begin

  if Assigned(FComparerFunc) then
    Result := FComparerFunc(X, Y)
  else
  begin
    if X = Y then
      Result := 0
    else if X < Y then
      Result := -1
    else
      Result := 1;
  end;

end;

[Muetze1]

Moin!

"Of Object" besagt aus, das du dort keine normale Funktionen zuweisen kannst, sondern es muss eine Funktion einer Klasse sein (also eine Methode). Alles andere lässt der Compiler nicht zu - ausser du machst es auf diesen bösen Weg mit der Adresse der Funktion, wie du es bei deinem originalen Code gemacht hast. Damit umgehst du die Typprüfung des Compilers und beseitigst somit seine Einwände - die aber berechtigt sind. Wie du siehst funktionieren beide Varianten nun mit einer direkten Zuweisung ohne Verrenkungen...

Und Sprints Methode über eine Property die Sortiermethode zu zuweisen ist genauso gut geeignet wie die Methode von TList, die einfach die Methode im Sort Aufruf mitnimmt...

MfG
Muetze1