Overloading

Overloading is the idea that we can have more than one function with the same name.

When we define multiple functions with the same name, C++ uses the types of the arguments (and only the types) to figure out which function to call.

So, for example, if we had these two functions:

int combine(double x, double y) {
    return (x+y)/2;
}

and

std::string combine(std::string x, std::string y) {
    x.append(" & ");
    x.append(y);
    return x;
}

We could write

cout << combine(3.142, 2.718) << endl
cout << combine("Chalk", "Cheese") << endl

and C++ will call the right function!

Rules for Resolving Overloading

C++ finds the right function using the number of arguments and their types.

• If there is a perfect match, it's found the right function and is done.
• Otherwise, it produces a list of candidates based on the conversions/promotions it could perform.
• If, out of that list of candidates, there is an overloaded function that is
  • Better than all the others for some arguments (i.e., fewer conversions); and,
  • No worse than any of the others for the remaining arguments, then
    • That function is the one that is used.
• Otherwise, the best choice is still ambiguous, and the compiler throws an error.

In our example, if we wrote combine(1,2), there is only one candidate that matches—the combine() for doubles—and so it wins.

Overloading Operators

The cool thing is, not only can we overload functions, we can also introduce new incarnations of C++'s existing operators, such as +, /, =, ++ and *.

You've written lines like

cout << 42 << 'x' << 3.14;

but there's actually a bunch of work being done “behind the scenes” to make that simple print command work. Now, with everything you've learned in today's lesson, we can actually break it down.

That code is equivalent to

((cout << 42) << 'x') << 3.14;

which is, in turn, equivalent to

{
    std::ostream& _temp1 = cout << 42;
    std::ostream& _temp2 = _temp1 << 'x';
    _temp2 << 3.14;
}

By convention, all these << operators return a reference to their left-hand argument, so our code is also equivalent to saying

cout << 42;         // calls operator<<(std::ostream, int)
cout << 'x';        // calls operator<<(std::ostream, char)
cout << 3.14;       // calls operator<<(std::ostream, double)

Now you can see how our (apparently) simple “print three values” code was actually calling three different functions.

That extensibility is a key principle. In C++ you can create your own classes that behave exactly like types that are built into the language. You can even overload the subscript operator, [], and the function-call operator, (), to make objects that are array-like or function-like.

(When logged in, completion status appears here.)