# Ada Programming/Function overloading


## Description

***Function overloading*** (also *method overloading*) is a programming
concept that allows programmers to define two or more functions with the
same name and in the same scope.

Each function has a unique signature (or header), which is derived from:

1.  function/procedure name
2.  number of arguments
3.  arguments\' type
4.  arguments\' order
5.  arguments\' name
6.  return type

Please note: Not all above signature options are available in all
programming languages.

  Language   1     2     3     4     5     6
  ---------- ----- ----- ----- ----- ----- -----
  Ada        yes   yes   yes   yes   yes   yes
  C++        yes   yes   yes   yes   no    no
  Java       yes   yes   yes   yes   no    no
  Swift      yes   yes   yes   yes   yes   yes

  : Available functions overloadings

Warning: Function overloading is often confused with function
overriding. In Function overloading, a function with a different
signature is created, adding to the pool of available functions. In
function overriding, however, a function with the same signature is
declared, replacing the old function in the context of the new function.

## Demonstration

Since functions\' names are in this case the same, we must preserve
uniqueness of signatures, by changing something from the ***parameter
list*** (last three alienees).

If the functions\' signatures are sufficiently different, the compiler
can distinguish which function was intended to be used at each
occurrence. This process of searching for the appropriate function is
called ***function resolution*** and can be quite an intensive one,
especially if there are a lot of equally named functions.

Programming languages supporting implicit type conventions usually use
promotion of arguments (i.e. type casting of integer to floating-point)
when there is no exact function match. The demotion of arguments is
rarely used.

When two or more functions match the criteria in function resolution
process, an ***ambiguity error*** is reported by compiler. Adding more
information for the compiler by editing the source code (using for
example type casting), can address such doubts.

The example code shows how function overloading can be used. As
functions do practically the same thing, it makes sense to use function
overloading.

\
\
` Generate_Number (MaxValue : Integer) `` Integer `\
`   `` Random_Type `` Integer `` 0 .. MaxValue;`\
`   `` Random_Pack `` `` `` (Random_Type);`\
` `\
`   G : Random_Pack.Generator;`\
\
`   Random_Pack.Reset (G);`\
`   `` Random_Pack.Random (G);`\
` Generate_Number;`\
\
\
` Generate_Number (MinValue : Integer;`\
`                          MaxValue : Integer) `` Integer`\
\
`   `` Random_Type `` Integer `` MinValue .. MaxValue;`\
`   `` Random_Pack `` `` `` (Random_Type);`\
` `\
`   G : Random_Pack.Generator;`\
\
`   Random_Pack.Reset (G);`\
`   `` Random_Pack.Random (G);`\
` Generate_Number;`

### calling the first function

The first code block will generate numbers from 0 up to specified
parameter *MaxValue*. The appropriate function call is:

` Number_1 : Integer := Generate_Number (10);`

### calling the second function

The second requires another parameter *MinValue*. Function will return
numbers above or equals *MinValue* and lower than *MaxValue*.

` Number_2 : Integer := Generate_Number (6, 10);`

## Function overloading in Ada

Ada supports all six signature options, but if you use the arguments\'
name as option, you will always have to name the parameter when calling
the function. i.e.:

`Number_2 : Integer := Generate_Number (MinValue => 6,`\
`                                       MaxValue => 10);`

Note that you cannot overload a generic procedure or generic function
within the same package. The following example will fail to compile:

` `` myPackage`\
`   `\
`     `` Value_Type `` (<>);  `\
`   `\
`   `\
`   `` Generic_Subprogram (Value : `` `` Value_Type);`\
`   ...`\
`   `\
`     `` Value_Type `` (<>); `\
`   `\
`   `\
`   `\
`   `\
`   `\
`   `` Generic_Subprogram;`\
`   ...`\
`   `\
`     `` Value_Type `` (<>); `\
`   `\
`   `\
`   `\
`   `\
`   `` Generic_Subprogram (Value : Value_Type) `` Value_Type;`\
` `` myPackage;`

## See also

### Wikibook

-   Ada Programming
-   Ada
    Programming/Subprograms

### Ada 95 Reference Manual

-   
-   
### Ada 2005 Reference Manual

-   
-   
