C++ 重载函数的调用不明确（两个函数在不同范围内）

代码：

错误：

namespace asd {
    class A { };
    void f(A &a) { }
}

void f(asd::A &a) { }

int main() {
    asd::A instance;
    f(instance);
    return 0;
}

为什么编译器在名称空间asd的作用域中搜索函数“f”？
为什么这叫做重载？这是两种不同的功能。
如果主函数是这样的，我会理解错误：

D:\>g++ -Wall -std=c++98 -pedantic a.cpp
a.cpp: In function 'int main()':
a.cpp:10:12: error: call of overloaded 'f(asd::A&)' is ambiguous
a.cpp:10:12: note: candidates are:
a.cpp:6:6: note: void f(asd::A&)
a.cpp:3:7: note: void asd::f(asd::A&)

我会得到一个错误。。。但是有了这个我不…

这种情况和我这样做的时候一样吗

int main() {
    using asd::f;
    asd::A instance;
    f(instance);
    return 0;
}

当你这样做的时候

std::cout << str;
// meaning 1:
std::operator<<(std::cout, str);
// meaning 2:
::operator<<(std::cout, str);

您告诉编译器“当我在当前范围内使用符号

f

时，实际上我指的是

asd:：f

”。这就是它起作用的原因

对于第一种情况，这是因为编译器查看

实例

（即

asd

）类型的范围以及全局范围。它叫。

当你这么做的时候

std::cout << str;
// meaning 1:
std::operator<<(std::cout, str);
// meaning 2:
::operator<<(std::cout, str);

您告诉编译器“当我在当前范围内使用符号

f

时，实际上我指的是

asd:：f

”。这就是它起作用的原因

对于第一种情况，这是因为编译器查看

实例

（即

asd

）类型的范围以及全局范围。它叫。

当你这么做的时候

std::cout << str;
// meaning 1:
std::operator<<(std::cout, str);
// meaning 2:
::operator<<(std::cout, str);

您告诉编译器“当我在当前范围内使用符号

f

时，实际上我指的是

asd:：f

”。这就是它起作用的原因

对于第一种情况，这是因为编译器查看

实例

（即

asd

）类型的范围以及全局范围。它叫。

当你这么做的时候

std::cout << str;
// meaning 1:
std::operator<<(std::cout, str);
// meaning 2:
::operator<<(std::cout, str);

您告诉编译器“当我在当前范围内使用符号

f

时，实际上我指的是

asd:：f

”。这就是它起作用的原因

---

对于第一种情况，这是因为编译器查看

实例

（即

asd

）类型的范围以及全局范围。它被称为。

C++执行依赖于参数的查找。这意味着，如果函数有一个特定类类型的参数，那么为了找到该函数，编译器将在包含该参数类型的命名空间中查找函数名

在下面的代码中，您已将实例指定为

class A

的变量，该变量是namespace

asd

using asd::f;

因此，它也将在

asd

名称空间中查找

f

。要解决此问题，请使用：

：：f（实例）

用于在全局命名空间中调用

f

，或

asd:：f（实例）位于
asd
命名空间中

这称为koenig查找。如果您想了解更多信息，请转到此处。
C++执行依赖于参数的查找。这意味着，如果函数有一个特定类类型的参数，那么为了找到该函数，编译器将在包含该参数类型的命名空间中查找函数名

在下面的代码中，您已将实例指定为
class A
的变量，该变量是namespace
asd

using asd::f;

因此，它也将在
asd
名称空间中查找
f
。要解决此问题，请使用：
：：f（实例）
用于在全局命名空间中调用
f
，或
asd:：f（实例）位于
asd
命名空间中

这称为koenig查找。如果您想了解更多信息，请转到此处。
C++执行依赖于参数的查找。这意味着，如果函数有一个特定类类型的参数，那么为了找到该函数，编译器将在包含该参数类型的命名空间中查找函数名

在下面的代码中，您已将实例指定为
class A
的变量，该变量是namespace
asd

using asd::f;

因此，它也将在
asd
名称空间中查找
f
。要解决此问题，请使用：
：：f（实例）
用于在全局命名空间中调用
f
，或
asd:：f（实例）位于
asd
命名空间中

这称为koenig查找。如果您想了解更多信息，请转到此处。
C++执行依赖于参数的查找。这意味着，如果函数有一个特定类类型的参数，那么为了找到该函数，编译器将在包含该参数类型的命名空间中查找函数名

在下面的代码中，您已将实例指定为
class A
的变量，该变量是namespace
asd

using asd::f;

因此，它也将在
asd
名称空间中查找
f
。要解决此问题，请使用：
：：f（实例）
用于在全局命名空间中调用
f
，或
asd:：f（实例）位于
asd
命名空间中

这称为koenig查找。如果你想了解更多，请点击这里

为什么编译器在命名空间asd的作用域中搜索函数“f”

依赖于参数的查找。参数类型
A
的作用域在
asd
中，因此也会在名称空间中搜索合适的重载

为什么这叫做重载？这是两种不同的功能

重载就是这个意思：两个同名但作用域不同的函数，或者使用不同的参数

这种情况和我这样做的时候一样吗

int main() {
    using asd::f;
    asd::A instance;
    f(instance);
    return 0;
}

是的，这可能意味着两者之一；但是由于没有
：：操作符
为什么编译器在命名空间asd的作用域中搜索函数“f”

依赖于参数的查找。参数类型
A
的作用域在
asd
中，因此也会在名称空间中搜索合适的重载

为什么这叫做重载？这是两种不同的功能

重载就是这个意思：两个同名但作用域不同的函数，或者使用不同的参数

这种情况和我这样做的时候一样吗

int main() {
    using asd::f;
    asd::A instance;
    f(instance);
    return 0;
}

是的，这可能意味着两者之一；但是由于没有
：：操作符
为什么编译器在命名空间asd的作用域中搜索函数“f”

依赖于参数的查找。参数类型
A
i