Anonyme Methoden in Delphi werden mit dem Schlüsselwort `reference` deklariert.

Sie repräsentieren Closures: aufrufbare Werte, die Variablen aus ihrem umgebenden Gültigkeitsbereich einschließen können.

In Delphi2Cpp werden anonyme Methoden in aufrufbare Wrapper-Typen übersetzt.

Dies erhält eine stärkere Typidentität und eine bessere Kompatibilität mit der Delphi-Semantik.

Delphi
type
  TFuncOfInt = reference to function(x: Integer): Integer;

C++ portable
typedef d2c::callback TFuncOfInt;

C++Builder
typedef System::Sysutils::_di_TFunc__2 System::Sysutils::_di_TFunc__2




Der generierte Typ kann Folgendes speichern:

- Lambdas

- freie Funktionen

- gekapselte Instanzmethoden


Zuweisung einer anonymen Methode



Delphi
var
  adder: TFuncOfInt;
begin
  adder :=
    function(X: Integer): Integer
    begin
      Result := X + Y;
    end;
end;




C++ portable
TFuncOfInt adder;
adder = [&](int X)
{
  return X + Y;
};




C++Builder
TFuncOfInt adder;
adder = d2c::make_sysutils_callable, int(int)>(
  [&](int X)
  {
    return X + Y;
  });








Anonyme Methoden (reference to) - Vergleichstabelle


  

  

    
Topic 
    
Delphi 
    
C++ Portable 
    
C++Builder 
  
  
  

  

    
**Type declaration** 
    
`TProc = reference to procedure;` 
    
`using TProc = d2c::callback<void()>;` 
    
`using TProc = System::Sysutils::_di_TProc;` 
  
  

    
**Representation** 
    
Closure with captured state 
    
std::function wrapper + identity 
    
Interface with Invoke() 
  
  

    
**Assign lambda** 
    
`p := procedure begin end;` 
    
`p = [&](){ };` 
    
`p = d2c::make_sysutils_callable<TProc>([]{});` 
  
  

    
**Assign free function** 
    
`p := GlobalProc;` 
    
`p = &GlobalProc;` 
    
`p = d2c::bind_free_proc0(&GlobalProc);` 
  
  

    
**Assign method** 
    
`p := Obj.Method;` 
    
`p = d2c::make_callback(Obj,&C::Method);` 
    
`p = d2c::bind_proc0(Obj,&C::Method);` 
  
  

    
**Invoke** 
    
`p();` 
    
`p();` 
    
`p->Invoke();` 
  
  

    
**Assigned check** 
    
`Assigned(p)` 
    
`if (p)` 
    
`if (p != nullptr)` 
  
  

    
**Pass as parameter** 
    
by value 
    
by value 
    
interface reference 
  
  

    
**Return from function** 
    
closure returned 
    
lambda returned 
    
interface returned 
  
  

    
**Use as event field** 
    
property field 
    
`d2c::callback` 
    
`_di_TProc` 
  
  

    
**Capture variables** 
    
automatic boxing 
    
reference capture (no boxing) 
    
boxed via interface instance 
  
  

    
**Type identity** 
    
distinct types 
    
preserved via typedef 
    
preserved via distinct interfaces 
  
  

    
**Overload resolution** 
    
exact type match 
    
exact typedef match 
    
exact interface type 
  
  

    
**Shared captured state** 
    
supported 
    
not automatic 
    
supported 
  
  

    
**Lifetime extension** 
    
automatic 
    
not automatic 
    
automatic via refcount 
  
  

    
**Equality** 
    
reference equality 
    
identity token 
    
interface equality