Anonymous methods in Delphi are declared using the keyword reference to.
They represent closures: callable values that may capture variables from their surrounding scope.

In Delphi2Cpp, anonymous methods are translated to callable wrapper types.

This preserves stronger type identity and better compatibility with Delphi semantics.

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




The generated type can store

- lambdas

- free functions

- wrapped instance methods


Assigning an Anonymous Method



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;
  });








Anonymous Methods (reference to) - Comparison Table


  

  

    
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