Cross Ref > Language Details

Delphi is a hybrid language so you can create either class methods (functions and procedures) or you can create global functions and procedures. When a function or procedure is part of a class, it is a class method.

[function/procedure] RoutineName : ReturnType;

As with C++, your custom routine must come before it's first usage or you have to prototype it in the Interface section.

Note: Contrast Delphi with Delphi Prism which is an OOP language (everything is within a class). Both Delphi and Delphi Prism are based on Object Pascal but implement OOP features differently and have some syntax differences too.

procedure SayHello(pName: String);
begin
  ShowMessage('Hello ' + pName);
end;

function Add(p1, p2 : Double): Double;
begin
  Result := p1 + p2;
end;

 Delphi Custom Routines (procedure, function)

ObjectPAL is a non-OOP language (an object-based language) that offers custom methods and custom procedures. When you create a custom method, you associate it with an existing object like a button, form, or library.

When calling a custom method or procedure that has a by reference parameter (uses var), then you cannot use a literal value. this is different than in many other languages which do allow you to pass literals by reference.

method sayHello(var pName String)
 msgInfo("", "Hello " + pName)
endMethod
 

method add(p1 Number, p2 Number) Number
 Return p1 + p2
endMethod

 ObjectPAL Custom Routines (method, procedure)  

Many objects in Delphi have events you can use to trigger code. For example, when you add a form to your project you have access to the form events such as onCreate, onShow, onHide, onDockDrop, etc. In addition, Delphi offers module level events initialization and finalization sections.

In Delphi, you can inline assembler code using the asm keyword.

Delphi introduced developer defined function and procedure inlining with Delphi 2005. Use the inline keyword to tell the compiler to try to inline a routine (a compiler hint). Since Delphi will only try to inline the routine, make sure you test for speed because inlining a routine can lead to slower code under some circumstances.

Syntax Example:   function Add(a, b: Integer): Integer; inline; begin end;

Delphi supports both method and operator overloading.

For method overloading, you use the overload keyword (all versions of the routine must include the overload keyword). The compiler chooses the correct method first based on the number of parameters, then on the type so you can have two overloaded methods with the same number of parameters so long as at least one parameter is different.

Another form of method overloading is with the use of default parameters, a shortcut syntax, where you specify a default parameter value.

Delphi also supports operator overloading with some operators.

function Add(a, b: integer): Integer;  overload;
begin
  Result := a+b;
end;

function Add(const msg: String; a, b: integer): String; overload;
begin
  Result := msg + IntToStr(a+b);
end;

 Delphi Overloading (overload)

Paradox & Overloading

• Operator - No.
• Method - No.

However, you can have the same named method or procedure so long as they are in different libraries. This is important if you use libraries in a class-like OOP way and wish to implement some form of polymorphism (i.e. libMember.Open and libVendor.Open). This is an OOP-like technique for implementing a subtyping-like polymorphism which is also known as inclusion polymorphism.

Also, some developers like to pass an array and then handle the array for a pseudo technique. Although not overloading, it's useful.

 ObjectPAL Overloading  

Object Pascal allows parameters of the same type to be listed together, separated by commas, and followed with a single data type (more params of different data types can follow, after a semi-colon).

Delphi also supports default parameters (a form of overloading).

By Reference or Value (and by constant): The default for parameters is by value. For by reference, add var in front of the parameter. Object Pascal also offers constant parameters where you add const in front of the parameter. A constant parameter is like a local constant or read-only parameter the compiler can optimize. You cannot assign a value to a constant parameter, nor can you pass one as a var parameter to another routine. (But when you pass an object reference as a constant parameter, you can still modify the object's properties.)

function Add(a, b: integer) : integer; 
begin
  Result := a + b;
end;
  
procedure ReplaceTime(var pDT: TDateTime; const pNewDT: TDateTime);
begin
end;

 Delphi Parameters (var, const)  

By Reference or Value (and by constant)
The default for parameters is by value. For by reference, add var in front of the parameter. ObjectPAL also offers constant parameters where you add const in front of the parameter. A constant parameter is like a read-only parameter the compiler can optimize. You cannot assign a value to a constant parameter.

Syntax Example:   method cmCode(s String) ;...s is by value. endMethod   method pushButton(var eventInfo Event)   ;...eventInfo is by reference. endMethod   method cmCode(Const s String)   ;...s is a constant read-only parameter. endMethod    proc cpNever() String   return "Never duplicate a line of code!" endProc

Within the implementation of a method, the identifier Self references the object in which the method is called. The Self variable is an implicit parameter for each object method. A method can use this variable to refer to its owning class.

ShowMessage('Self=' + Self.ClassName);

A built-in object variable that represents the UIObject to which the currently executing code is attached.

Syntax Example:   method pushButton(var eventInfo Event)   msgInfo("", self.Name) endMethod