What is the use/advantage of function overloading?

language-agnostic oop overloading

34,158

Solution 1

IMO, the primary benefit is consistency in the naming of methods / functions which logically perform very similar tasks, and differ slightly in by accepting different parameters. This allows the same method name to be reused across multiple implementations.

e.g. The overloads: (Good)

function Person[] FindPersons(string nameOfPerson) { ... }
function Person[] FindPersons(date dateOfBirth) { ... }
function Person[] FindPersons(int age, string dogsName) { ... }

Are preferable to 'uniquely named' functions: (Worse)

function Person[] FindPersonsByName(string nameOfPerson) { ... }
function Person[] FindPersonsByDOB(date dateOfBirth) { ... }
function Person[] FindPersonsByAgeAndDogsName(int age, string dogsName) { ... }

This way the coder writing a client which calls / consumes these functions can operate at a higher level of conceptual thinking ("I need to find a person") and doesn't need to remember / locate a contrived function name.

With static typing, the compiler will be left to match the applicable overload based on the usage parameters. For dynamic typing, this same match up will happen at run time, possibly resulting in failure if no appropriate match is found.

Solution 2

Very valid question.

You get consistency in naming, but at the cost of ambiguity about exact implementation.

The real issue is human memory for method names, right? we find it easier to remember names that are commonly used.
and economy of typing, allowing for shorter method names? fewer different names means (mathematically) that the name itself carries less information.

These two issues shouldn't be any concern, with IDEs that find/guess/insert method names rapidly based on the first few characters, and parameter/return types.

But I do think there is a cost, in preciseness of coding, as well as a benefit.

Solution 3

Overloading is a form of polymorphism. It allows the programmer to write functions to do conceptually the same thing on different types of data without changing the name. (It also allows the programmer to write functions to do conceptually different things depending on parameters, but that's a Real Bad Idea.)

This allows consistency in notation, which is good both for reading and for writing code. I/O is a very common use. In most languages in common use, there's a function or operator that will output whatever you like, such as printf() and kin in C, operator<<() in C++, PRINT in the old BASICS I used to use, whatever. Languages that require functions like printint(), printstring(), printfloat(), and the like have never caught on.

It works very well with C++ templates and any other construct where you don't necessarily know what the variable type is at the time of writing the code.

Solution 4

Multiple behaviors to the same function based on the parameters.

Your function may want to work with some optional details. For example, the following example wants to add a member to the Members object, with whatever detail the user knows. Here age is the minimum detail to create a member, age and memberOf are optional. [Note: definition of functions are not provided in the code snippet.]

public class Members
{
    public System.Collections.Generic.List<Member> TeamMembers;

    public AddMember(Member m) {}
    public AddMember(string name) {}
    public AddMember(string name, int age) {}
    public AddMember(string name, int age, string[] memberOf) {}

    public class Member
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string[] MemberOf { get; set; }
    }
}

You may want your method to be suitable for multiple type of objects. ex. Console.WriteLine() method is capable of writing empty line, bool, int, string, char[], float etc. on the console. This was made possible because of function overloading.

Solution 5

A function/method is sometimes able to take different kinds of parameters in order to do it's job. This is the time for function overloading. Otherwise, you would have to have different functions for the same functionality, which is confusing and bad practice.

Constructors are functions, so they can be overloaded. This is very handy.
When you first get into overloading, it's easy to get over-fancy, thinking you're doing future developers a favor by giving them more convenient options. Try to avoid this. Unneeded overloads can confuse future developers and cause unnecessary code to maintain.

View more solutions

34,158