Function overloading

In some programming languages, function overloading or method overloading is the ability to create multiple methods of the same
name with different implementations. Calls to an overloaded function will run a specific implementation of that function appropriate
to the context of the call, allowing one function call to perform dif
ferent tasks depending on context.

For example, doTask() and doTask(object O) are overloaded methods. To call the latter, an object must be passed as a parameter,
whereas the former does not require a parameter, and is called with an empty parameter field. A common error would be to assign a
default value to the object in the second method, which would result in anambiguous call error, as the compiler wouldn't know which
of the two methods to use.

Another appropriate example would be a Print(object O) method. In this case one might like the method to be different when
printing, for example, text or pictures. The two different methods may be overloaded as Print(text_object T); Print(image_object P).
If we write the overloaded print methods for all objects our program will "print", we never have to worry about the type of the object,
and the correct function call again, the call is always:Print(something).

Contents
Rules in function overloading
Constructor overloading
Complications
Caveats
See also
References
External links

Rules in function overloading

The overloaded function must differ either by the arity or data types
The same function name is used for various instances of function call,
It is a classification of static polymorphism in which a function call is resolved using the 'best match technique', i.e. the function is
resolved depending upon the argument list. Method overloading is usually associated with statically-typed programming languages
that enforce type checking in function calls. When overloading a method, you are really just making a number of different methods
that happen to have the same name. The determination of which of these methods are used is resolved compile
at time.

Function overloading is also known as compile-time polymorphism in Java and is also known as static polymorphism in Java.

Method overloading should not be confused with forms of polymorphism where the correct method is chosen at runtime, e.g. through
virtual functions, instead of statically.

Example: function overloading in C++

#include <iostream>

// volume of a cube
int volume (const int s)
{
return s*s*s;
}

// volume of a cylinder
double volume (const double r, const int h)
{
return 3.1415926 *r*r*static_cast <double >(h);
}

// volume of a cuboid
long volume (const long l, const int b, const int h)
{
return l*b*h;
}

int main()
{
std::cout << volume (10);
std::cout << volume (2.5, 8);
std::cout << volume (100, 75, 15);

return 0;
}

In the above example, the volume of various components are calculated using the same function call "volume", with arguments
differing in their data type or their number.

Constructor overloading
Constructors, used to create instances of an object, may also be overloaded in some object-oriented programming languages. Because
in many languages the constructor’s name is predetermined by the name of the class, it would seem that there can be only one
constructor. Whenever multiple constructors are needed, they are to be implemented as overloaded functions. In C++, default
constructors take no parameters, instantiating the object members with their appropriate default values. For example, a default
constructor for a restaurant bill object written inC++ might set the tip to 15%:

Bill()
: tip(0.15), // percentage
total(0.0)
{ }

The drawback to this is that it takes two steps to change the value of the created Bill object. The following shows creation and
changing the values within the main program:

Bill cafe;
cafe.tip = 0.10;
cafe.total = 4.00;

By overloading the constructor, one could pass the tip and total as parameters at creation. This shows the overloaded constructor with
two parameters. This overloaded constructor is placed in the class as well as the original constructor we used before. Which one gets
used depends on the number of arguments provided when the new Bill object is created (none, or two):

Bill(double tip, double total)

: tip(tip),
total(total)
{ }

Now a function that creates a new Bill object could pass two values into the constructor and set the data members in one step. The
following shows creation and setting the values:

Bill cafe(0.10, 4.00);

This can be useful in increasing program efficiency and reducing code length.
Another reason for constructor overloading can be to enforce mandatory data members. In this case the default constructor is declared
private or protected (or preferably deleted since C++11) to make it inaccessible from outside. For the Bill above total might be the
only constructor parameter - since a Bill has no sensible default for total - whereas tip defaults to 0.15.

Complications
Two issues interact with and complicate function overloading:name masking (due to scope) and implicit type conversion.

If a function is declared in one scope, and then another function with the same name is declared in an inner scope, there are two
natural possible overloading behaviors: the inner declaration masks the outer declaration (regardless of signature), or both the inner
declaration and the outer declaration are both included in the overload, with the inner declaration masking the outer declaration only
if the signature matches. The first is taken in C++: "in C++, there is no overloading across scopes."[1] As a result, to obtain an
overload set with functions declared in different scopes, one needs to explicitly import the functions from the outer scope into the
inner scope, using theusing keyword

Implicit type conversion complicates function overloading because if the types of arguments do not exactly match the signature of
one of the overloaded functions, but can match after type conversion, resolution depends on which type conversion is chosen.

These can combine in confusing ways: an inexact match declared in an inner scope can mask an exact match declared in an outer
scope, for instance.[1]

For example, to have a derived class with an overloaded function taking a double or an int, using the function taking an int from the
base class, in C++, one would write

class B {
public :
void f(const int i);
};

class D : public B {
public :
using B::f;
void f(const double d);
};

Failing to include the using results in an int argument passed to f in the derived class being converted to a double and matching the
function in the derived class, rather than in the base class; including using results in an overload in the derived class and thus
matching the function in the base class.

Caveats
If a method is designed with an excessive number of overloads, it may be difficult for developers to discern which overload is being
called simply by reading the code. This is particularly true if some of the overloaded parameters are of types that are inherited types
of other possible parameters (for example "object"). An IDE can perform the overload resolution and display (or navigate to) the
correct overload.

Type based overloading can also hamper code maintenance, where code updates can accidentally change which method overload is
chosen by the compiler.[2]

See also
Abstraction (computer science)
Constructor (computer science)
Dynamic dispatch
Factory method pattern
Method signature
 Method overriding
Object-oriented programming
Operator overloading

References
1. "Why doesn't overloading work for derived classes?(http://www.stroustrup.com/bs_faq2.html#overloadderived)",
Bjarne Stroustrup's C++ Style and T
echnique FAQ (http://www.stroustrup.com/bs_faq2.html), Bjarne Stroustrup
2. Bracha, Gilad (September 3, 2009)."Systemic Overload" (https://gbracha.blogspot.fr/2009/09/systemic-overload.htm
l). Room 101.

External links
Bertrand Meyer: Overloading vs Object T
echnology, in Journal of Object-Oriented Programming (JOOP), vol. 14, no.
4, October–November 2001, availableonline

Retrieved from "https://en.wikipedia.org/w/index.php?title=Function_overloading&oldid=818893269

"

This page was last edited on 6 January 2018, at 06:14.

Text is available under theCreative Commons Attribution-ShareAlike License ; additional terms may apply. By using this
site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of theWikimedia
Foundation, Inc., a non-profit organization.