Overloading and Default Arguments

Overloading exists because inventing a new name for every parameter type scales badly. C, which lacks it, needs abs, labs, fabs, and fabsf for one idea — absolute value. C++ lets one name serve them all and picks the right body from the argument types at compile time; the standard library leans on this everywhere (std::to_string alone has nine overloads).

Same name, different parameters

C++ lets several functions share a name as long as their parameter lists differ. This is overloading, and the compiler picks the right one from the argument types at the call site:

int    twice(int x)    { return x * 2; }
double twice(double x) { return x * 2.0; }
std::string twice(const std::string& s) { return s + s; }

twice(4);       // calls the int version, 8
twice(1.5);     // calls the double version, 3.0
twice(std::string("ab"));  // "abab"

Python cannot do this (a second def twice replaces the first). Note that the return type alone is not enough to overload: two functions differing only in return type will not compile.

Default arguments

void repeat(std::string s, int times = 2) { ... }

repeat("hi");      // times is 2
repeat("hi", 5);   // times is 5

Defaults must be the trailing parameters, same as Python.