Name

Function Keyword

Syntax

function Name: Return type; Directives...
function Name(Parameters...): Return type; Directives...

type Name = function(Parameters...): Return type;
type Name = function(Parameters...): Return type of object;

Description

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.

Tips and Tricks

  • 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)

Examples

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.

See Also

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
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset