Function Keyword
functionName
:Return type
;Directives
... functionName
(Parameters
...):Return type
;Directives
... typeName
= function(Parameters
...):Return type
; typeName
= function(Parameters
...):Return type
of object;
A function is a subroutine that returns a value. In the interface section of a unit, only the function header (its name, parameters, return type, and directives, but not the body) can appear. You can also define a functional type.
In the implementation section, you must provide a complete function
definition for every function declared in the interface section. (See
the external
directive to learn how to define a
function without providing a body.) You can omit the parameters in
the implementation section if the function is not overloaded. If you
provide the parameters, they must match exactly (including the
parameter names) with the function header in the interface section.
A function’s implementation should not repeat the directives that appear first with the function header.
Although it seems like an additional maintenance burden to keep a copy of the header in the function’s implementation, it is a great benefit to the person who maintains the code. It is inconvenient to have to jump to the function’s declaration just to learn about the function’s parameters.
You can declare multiple functions with the same name but different
arguments by using the overload
directive.
A function can be declared in a class declaration, in which case it
is called a method. A method can be declared with the
dynamic
or virtual
directives
to declare a virtual method. A virtual method can be declared with
the abstract
directive, in which case you must not
provide a function implementation.
The default calling convention is register
. You
can choose a different calling convention with the
cdecl
, pascal
,
safecall
, or stdcall
directives.
Directives are optional, but if you include them, you must use the following order for methods:
reintroduce
overload
virtual
, dynamic
,
override
cdecl
, pascal
,
register
, safecall
,
stdcall
abstract
(only if virtual
,
dynamic
, or override
appears
earlier)
type TRandFunc = function(Min, Max: Integer): Integer; TRandMethod = function(Max: Integer): Integer of object; TRandClass = class private fMin: Integer; public constructor Create(Min: Integer); function IntFunc(Max: Integer): Integer; property Min: Integer read fMin; end; function TestFunc(Min, Max: Integer): Integer; begin Result := Random(Max - Min + 1) + Min; end; function TRandClass.IntFunc(Max: Integer): Integer; begin Result := Random(Max - Min + 1) + Min; end; var F: TRandFunc; M: TRandMethod; O: TRandClass; begin O := TRandClass.Create(10); try F := TestFunc; WriteLn(F(1, 6)); M := O.IntFunc; WriteLn(M(50)); finally O.Free; end; end.
Abstract Directive, CDecl Directive, Class Keyword, External Directive, Object Keyword, Overload Directive, Pascal Directive, Procedure Keyword, Result Variable, SafeCall Directive, StdCall Directive, Type Keyword, Virtual Directive |