int operator+(int,int);
double operator+(double,double);
...

T operator+(T,T);

struct X {
    void f();
};

struct Y {
    void f();
};

struct X {};
struct Y { Y(X); void f(); };
void g(Y);

X x;
g(x); // законное поведение: g(Y(x)), т.к. есть неявное приведение X к Y
x.f(); // внезапно, Y(x).f(), по той же самой причине

During overload resolution, the implied object argument is indistinguishable from other arguments. The implicit object parameter, however, retains its identity since conversions on the corresponding argument shall obey these additional rules:
— no temporary object can be introduced to hold the argument for the implicit object parameter;
— no user-defined conversions can be applied to achieve a type match with it; [...]

НИ>>Почему "overload resolution" не переименовали во что-нибудь вроде "candidate selection" — ХЗ

I>namespace N {
I>    void f(int) {}
I>};
I>using namespace N;

I>void f(char const*) {}

I>int main()
I>{
I>    f(123);
I>    f("abcd");
I>}
I>

namespace N {
    void f() {}
};
using namespace N;

int f() { return 0;} // "перегруженная" функция отличается только возращаемым типом

int main(){ f(); }

I>class A {
I>    struct X {};

I>    void f(X);

I>    struct Y {};

I>    void f(Y);
I>};
I>

I>class A {
I>    struct X {
I>        void f();
I>    };

I>    struct Y {
I>        void f();
I>    };
I>};
I>

struct X {};
struct Y { Y(X); void f(); };
void g(Y);

X x;
g(x); // законное поведение: g(Y(x)), т.к. есть неявное приведение X к Y
x.f(); // внезапно, Y(x).f(), по той же самой причине

class A {
    struct X {};

    void f(X);

    struct Y {};

    void f(Y);
};

class A {
    struct X {
        void f();
    };

    struct Y {
        void f();
    };
};

// 1)
&A::f;    // ill-formed, здесь посредством name lookup находятся обе A::f

// 2)
&A::X::f; // well-formed, здесь посредством name lookup находится только A::X::f

ЮЖ>>void f();
ЮЖ>>int f();

ЮЖ>>int main(){}
I>

namespace N {
    void f(int) {}
};
using namespace N;

void f(char const*) {}

When two or more different declarations are specified for a single name in the same scope, that name is
said to be overloaded.
...
two declarations in the same scope that declare the same name but with different types are called overloaded declarations

function selection process is called overload resolution

Overload resolution is a mechanism for selecting the best function to call given a list of expressions that are to be the arguments of the call and a set of candidate functions that can be called based on the context of the call.

struct X {
    X& operator=(X const&);
};

struct Y {
    Y& operator=(Y const&);
};

    x_or_y.f();

class A
{
int i;
A& operator + (const A&);
};

A a,b;
a = b + a;

overload. To assign an operator, identifier, or literal more than one meaning, depending upon the data types associated with it at any given time during program execution

namespace N {
    void f(int) {}
};
using namespace N;

void f(char const*) {}

int main()
{
    f(123);
    f("abcd");
}

struct X {};

void f(X);

struct Y {};

void f(Y);

struct X {
    void f();
};

struct Y {
    void f();
};

struct X {};

void f(X);

struct Y {};

void f(Y);

struct X {};

void f(X&);

struct Y {};

void f(Y&);

4 A name is a use of an identifier (2.11), operator-function-id (13.5), literal-operator-id (13.5.8), conversionfunction-
id (12.3.2), or template-id (14.3) that denotes an entity or label (6.6.4, 6.1).

C>>Так речь то вся идёт о том, что в некоторых случаях вводится первая и единственная возможная интерпретация...

class A
{
int i;
};

A a,b;
a = b + a;

class A
{
int i;
A& operator + (const A&);
};

A a,b;
a = b + a;

class A {
    struct X {};

    void f(X);

    struct Y {};

    void f(Y);
};

class A {
    struct X {
        void f();
    };

    struct Y {
        void f();
    };
};

class A {
    struct X {};

    void f(X);

    struct Y {};

    void f(Y);
};

class A {
    struct X {
        void f();
    };

    struct Y {
        void f();
    };
};

void f();

class A {
  void f();
  void f1(); 
};

void A::f1() { f(); }

V>void f();

V>class A {
V>  void f();
V>  void f1(); 
V>};

V>void A::f1() { f(); }

namespace N {
    void f(int) {}
};
using namespace N;

void f(char const*) {}

int main()
{
    f(123);
    f("abcd");
}

I>namespace N {
I>    void f(int) {}
I>};
I>using namespace N;

I>void f(char const*) {}

I>int main()
I>{
I>    f(123);
I>    f("abcd");
I>}
I>

namespace N {
    void f(int) {}
};
using namespace N;

void f(char const*) {}

struct A
{
    operator int() const { return 0; }
    operator char const *() const { return 0; }
};

int main()
{
    N::f(A()); // OK
    ::f(A());  // OK
    f(A());    // ill-formed
}

НИ>Почему "overload resolution" не переименовали во что-нибудь вроде "candidate selection" — ХЗ

namespace N {
    void f(int) {}
};
using namespace N;

void f(char const*) {}

int main()
{
    f(123);
    f("abcd");
}

namespace N {
    void f(int) {}
}
using namespace N;

void f(int) {}

int main()
{
    f(1); // error C2668: 'f' : ambiguous call to overloaded function
}

namespace N {
    void f(int) {}
}
using namespace N;

void f(int) {}

int main()
{
    f(1); // error: more than one instance of overloaded function "f"
}

ЮЖ>namespace N {
ЮЖ>    void f() {}
ЮЖ>};
ЮЖ>using namespace N;

ЮЖ>int f() { return 0;} // "перегруженная" функция отличается только возращаемым типом

ЮЖ>int main(){ f(); }

13.1 Overloadable declarations [over.load]
1 Not all function declarations can be overloaded. Those that cannot be overloaded are specified here. A
program is ill-formed if it contains two such non-overloadable declarations in the same scope. [Note: this
restriction applies to explicit declarations in a scope, and between such declarations and declarations made
through a using-declaration (7.3.3). It does not apply to sets of functions fabricated as a result of name
lookup (e.g., because of using-directives) or overload resolution (e.g., for operator functions). ]

13.1 Overloadable declarations [over.load]
. . .
[Note: this
restriction applies to explicit declarations in a scope, and between such declarations and declarations made
through a using-declaration (7.3.3). It does not apply to sets of functions fabricated as a result of name
lookup (e.g., because of using-directives) or overload resolution (e.g., for operator functions). ]

struct x {};
struct y {};

void x() {}

namespace
{
    void y();
}

int main()
{
    x(); // well-formed: x is function
    y(); // ill-formed: y is ambiguous
}

void f();
int f();

int main(){}

ЮЖ>void f();
ЮЖ>int f();

ЮЖ>int main(){}

int f();
void f();
//...
// C2556: 'void f(void)' : overloaded function differs only by return type from 'int f(void)'

int f();
ЮЖ>void f();
ЮЖ>//...
ЮЖ>// C2556: 'void f(void)' : overloaded function differs only by return type from 'int f(void)'

namespace N {
    void f(int) {}
}
using namespace N;

void f(int) {}

int main()
{
    f(1); // error C2668: 'f' : ambiguous call to overloaded function
}

void f(char*);
void g() {
  extern void f(int);
  f("asd"); // error, there is no f(char*) in this scope
}

// "сами по себе" ф-ии не перегружают друг друга 
namespace M { void f(int); }
namespace N { void f(char*); }

namespace { 
  using namespace N; 
  using namespace M; 
  // это определяется контекстом
  f("asd");
}

I>>namespace N {
I>>    void f(int) {}
I>>}
I>>using namespace N;

I>>void f(int) {}

I>>int main()
I>>{
I>>    f(1); // error C2668: 'f' : ambiguous call to overloaded function
I>>}