Сигнатуры и перегрузкаSignatures & overloading

Сигнатура функции — её имя плюс типы и порядок параметров (возвращаемый тип в сигнатуру не входит — по нему нельзя перегружать функции). Перегрузка (overloading) — механизм, позволяющий объявить несколько функций с одинаковым именем, но разными сигнатурами; все они образуют overload set — множество кандидатов, из которого компилятор выбирает одну функцию под конкретный вызов.A function's signature is its name plus the types and order of its parameters (the return type isn't part of the signature — functions can't be overloaded on it alone). Overloading is the mechanism that lets several functions share a name but differ in signature; together they form an overload set — the pool of candidates the compiler picks exactly one from for a given call.

void print(int x)          { std::cout << "int: " << x; }
void print(double x)       { std::cout << "double: " << x; }
void print(const std::string& x) { std::cout << "string: " << x; }

print(42);       // вызовет print(int)// calls print(int)
print(3.14);     // вызовет print(double)// calls print(double)
print("hi"s);     // вызовет print(const string&)// calls print(const string&)

Для каждого кандидата компилятор ранжирует, насколько «дёшево» аргумент вызова преобразуется к типу параметра, и выбирает кандидата с наименьшей суммарной стоимостью преобразований по всем аргументам. Упрощённый порядок предпочтения (от лучшего к худшему):For every candidate, the compiler ranks how "cheaply" each call argument converts to the parameter's type, and picks the candidate with the lowest total conversion cost across all arguments. A simplified order of preference (best to worst):

Если после ранжирования остаётся ровно один кандидат с наилучшей суммарной стоимостью — он и выбирается. Если несколько кандидатов оказываются равно хороши для данного вызова — это ошибка компиляции «неоднозначный вызов» (ambiguous call), а не случайный выбор одного из них.If exactly one candidate ends up with the best total cost after ranking, that one is chosen. If several candidates tie for equally good, that's an "ambiguous call" compile error — never an arbitrary pick among them.

void handle(long x)   { std::cout << "long"; }
void handle(double x) { std::cout << "double"; }

handle(5);   // "long" — int→long это стандартное преобразование, int→double тоже,// "long" — int→long is a standard conversion, and so is int→double,
          // но int→long считается более "близким" (той же категории — целочисленное)// but int→long is ranked "closer" (same category — integral)

Это именно тот механизм, который делает explicit на одноаргументных конструкторах важным (см. страницу про конструкторы): без него конструктор участвует в overload resolution как ещё один источник кандидатов через пользовательское преобразование, что может привести к вызову неожиданной перегрузки без единой ошибки компиляции.This is exactly the mechanism that makes explicit on single-argument constructors matter (see the constructors page): without it, a constructor joins overload resolution as another source of candidates via user-defined conversion, which can trigger an unexpected overload with no compile error at all.

• cppreference — Overload resolution
• cppreference — Implicit conversions