Function overloading simply means that the same function is defined more than once, but each time with a different formal parameter list. The parameter lists must differ at least in one of its elements type. When the compiler encounters a function call, it will look at the function parameters to decide which one of the defined functions it should call. This can be useful when the same function must be defined for different types.
For example, in a hypothetical RTL, the Random procedure could be defined as:
When the compiler encounters a call to the Random function, it will first search which function it should use. It therefore checks the parameters in a function call, and looks if there is a function definition which matches the specified parameter list. If the compiler finds such a function, a call is inserted to that function. If no such function is found, a compiler error is generated.
Functions that have a cdecl modifier cannot be overloaded. (Technically, because this modifier prevents the mangling of the function name by the compiler).
Prior to version 1.9 of the compiler, the overloaded functions needed to be in the same unit. Now the compiler will continue searching in other units if it doesn’t find a matching version of an overloaded function in one unit, and if the overload keyword is present.
If the overload keyword is not present, then all overloaded versions must reside in the same unit, and if it concerns methods part of a class, they must be in the same class, i. e. the compiler will not look for overloaded methods in parent classes if the overload keyword was not specified.
Remark Note that if you redefine (and overload) compiler internal functions, the original compiler functions are no longer available. This is for instance the case with Inc() and Dec()