C++进阶--Koenig lookup 依赖于实参的名字查找

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

//############################################################################
/*
* Koenig Lookup / Argument Dependent Lookup (ADL)
*/// 例1: 什么是Koenig查找
namespace A
{
struct X {};
void g( X ) { cout << " calling A::g() \n"; }
}// void g( X ) { cout << " calling A::g() \n"; } //如果再加一个函数，会编译不过int main() {
A::X x1;
A::g(x); //正常
g(x1); // 移除A::并不会报错，会到实参所在的命名空间查找
}// 例2:
class C {
public:
struct Y {};
static void h(Y) { cout << "calling C::h() \n"; }
};int main() {
C::Y y;
h(y); // Error Koenig查找只对命名空间有效，对类无效
}// 例3:
namespace A
{
struct X {};
void g( X ) { cout << " calling A::g() \n"; }
}class B {
void g(A::X ) { cout << "calling B::g() \n" ; }
};class C : public B {
public:
void j() {
A::X x;
g(x);
}
};int main() {
C c;
c.j(); //没有歧义，先在类中查找，没找到再去global和Koenig查找
}// 名字隐藏的情况：命名空间的例子
namespace A
{
struct X {};
void g(X ) { std::cout << " calling A::g() \n"; } namespace C {
void g( ) { std::cout << "calling C:g() \n" ; }
void j() {
//using A::g;
g(8); //编译不过，名字遮蔽
X x;
g(x); //Koenig原则同样有效
}
}
}int main() {
A::C::j();
}/*
* 名字查找顺序
*
* 命名空间:
* 当前作用域 => 外面一层作用域 => ... => 全局作用域
*
* 要覆写顺序:
* 1. 使用限定符或者using声明
* 2. Koenig lookup
*
* 类:
* 当前类作用域 => 父类作用类 => ... => 全局域
*
* 要覆写顺序::
* - 使用限定符或者using声明
*
*
* 名字隐藏
* 当高层作用域定义了和低层作用域相同名字的函数
*//*
* 为啥要有Koenig Lookup?
*/// 例1:
namespace A
{
struct X {};
void g( X ) { cout << " calling A::g() \n"; }
void g( ) { cout << " calling A::g() \n"; }
}int main() {
A::X x1;
g(x1); // Koenig Lookup, or Argument Dependent Lookup (ADL)
g(); // Error
}/*
* 1. 实际原因
*/ std::cout << "Hi.\n"; // 这里的数据运算符会调用 std::operator<<，而不用显式指定 std::cout std::<< "Hi.\n"; // 如果没有Koenig查找，要写成这种形式，编译不过
std::operator<<(std:cout, "Hi,\n"); //正确的写法/*
* 2. 理论原因:
* -- 什么是类的接口?
*/namespace A
{
class C {
public:
void f() = 0;
void g() = 0;
};
void h(C); //是C的接口的一部分
ostream& operator<<( ostream&, const C& ); //是C的接口的一部分
}
void j(C); //不就是C的接口的一部分/*
* 类的定义:
* 类是描述一组数据以及操作这些数据的函数的集合。
*//*
* 工程上的原则:
* 1. 对C类进行操作且跟C在同一个命名空间的函数是C的接口的一部分
* 2. 所以作为C的接口的一部分的函数需要在同一个命名空间下
*/ A::C c;
c.f(); //可以直接调用
h(c); //可以直接调用namespace A {
class C {};
int operator+(int n, A::C) { return n+1; } //如果放在外面可能会出现问题，万一std命名空间中定义了其他函数，就不会找到这个函数
}int main()
{
A::C arr[3];
std::accumulate(arr, arr+3, 0); // return 3
}// 定义在C++标准库<numeric>
namespace std {
template <class InputIterator, class T>
T accumulate ( InputIterator first, InputIterator last, T init )
{
while ( first!=last )
init = init + *first++;
return init;
}
}