Name

Procedure Keyword

Syntax

procedure Name;
procedure Name(Parameters...);

type Name = procedure(Parameters...);
type Name = procedure(Parameters...) of object;

Description

The procedure keyword declares a subroutine that does not have a return type. You can also declare a procedural type.

In the interface section of a unit, only the procedure header (its name, parameters, and directives, but not the body) can appear.

In the implementation section, you must provide a complete definition for every procedure declared in the interface section. (See the external directive to learn how to define a procedure without providing a body.) You can omit the parameters in the implementation section if the procedure is not overloaded. If you provide the parameters, they must match exactly (including the parameter names) with the procedure header in the interface section.

A procedure’s implementation should not repeat the directives that appeared first with the procedure header.

Tips and Tricks

  • Although it seems like an additional maintenance burden to keep a copy of the header in the procedure’s implementation, it is a great benefit to the person who maintains the code. It is inconvenient to have to jump to the procedure’s declaration just to learn about its parameters.

  • You can declare multiple procedures with the same name by using the overload directive.

  • A procedure 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 procedure 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 (cannot mix with message)

  • virtual, dynamic, override, message

  • cdecl, pascal, register, safecall, stdcall

  • abstract (only if virtual, dynamic, or override appears earlier)

Example

type
  TRandProc = procedure(var Rand: Integer; Max: Integer);
  TRandMethod = procedure(var Rand: Integer) of object;
  TRandClass = class
  private
    fMin, fMax: Integer;
  public
    constructor Create(Min, Max: Integer);
    procedure GetRand(var Rand: Integer);
    property Min: Integer read fMin;
    property Max: Integer read fMax;
  end;

procedure TestRand(var Rand: Integer; Max: Integer);
begin
  Rand := Random(Max);
end;

procedure TRandClass.GetRand(var Rand: Integer);
begin
  Rand := Random(Max - Min + 1) + Min;
end;

var
  P: TRandProc;
  M: TRandMethod;
  O: TRandClass;
  I: Integer;
begin
  O := TRandClass.Create(1, 6);
  try
    P := RandProc;
    P(I, 100);
    WriteLn(I);
    M := O.GetRand;
    M(I);
    WriteLn(I);
  finally
    O.Free;
  end;
end.

See Also

Abstract Directive, CDecl Directive, Class Keyword, Dynamic Directive, External Directive, Function Keyword, Message Directive, Object Keyword, Overload Directive, Pascal Directive, Register Directive, Reintroduce Directive, 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