今天在《Exceptional C++》上看到的两个有意思的东西

一：

对于以下代码：

/* * Int.h*/#include <ostream>struct Int{    std::ostream & print(std::ostream & os) const;    /* other codes */};std::ostream & operator << (std::ostream & os, const Int & i){    return(i.print(os));}

为了将编译期依存性减至最小，我们一般会用一个ostream的前置声明，来取代<ostream>头文件的包含：

/* * Int.h*/class ostream;struct Int{    std::ostream & print(std::ostream & os) const;    /* other codes */};std::ostream & operator << (std::ostream & os, const Int & i){    return(i.print(os));}

也许在过去是可以的(当时ostream是个类，也不在namespace std中)，然而在现今它是非法的，原因有二：

1  ostream现在是在namespace std里，程序员是不允许声明namespace std任何东西的；

2  ostream现在是一个模板的typedef，它是由basic_ostream<char> typedef而成的，不仅在任何情况下前置声明basic_ostream<char>模板都会造成混乱，而且根本不可能可靠地进行前置声明，因为库的各种实现产品可能自行其事，比如加入自己额外的模板参数(在标准要求之外的)，你的代码当然不会知道这些了--这是不允许程序员自己声明namespace std里元素的主要原因之一。

标准库为我们提供了头文件<iosfwd>，它包含了所有流模板(包括basic_ostream)及其标准的typedef(包括ostream)的前置声明，因此我们所需要做的只是用它替代<ostream>头文件。

/* * Int.h*/#include <iosfwd>struct Int{    std::ostream & print(std::ostream & os) const;    /* other codes */};std::ostream & operator << (std::ostream & os, const Int & i){    return(i.print(os));}

二：

Koenig查找(简化版)：

如果提供一个类类型的函数参数，那么在查找正确的函数名时，编译器将考虑包含参数类型的名字空间内匹配的函数名。

 

接口规则：对于类X，所有函数，包括自由函数，只要符合如下条件：

1  “提及”X；

2  与X“一起提供”(在相同的头文件或在同一个namespace中)。

逻辑上都是X的一部分，因为它们构成了X接口的一部分。

 

下面是Myers例子：

namespace NS{    class T { };}void f(NS::T) { }int main(){    f(NS::T()); // OK    return(0);}

 

namespace NS{    class T { };    void f(T) { } // new function}void f(NS::T) { }int main(){    f(NS::T()); // error: ambiguous    return(0);}

#include <iostream>using namespace std;namespace A{    class T { };        ostream & operator << (ostream & os, const T &)    {        return(os << "A");    }}namespace B{    ostream & operator << (ostream & os, const A::T &)    {        return(os << "B");    }    void g(A::T param) { cout << param; } // error: ambiguous}int main(){    return(0);}

 

namespace A{    class T { };    void f(const T &) { }}namespace B{    void f(const A::T &) { }    void g(A::T param) { f(param); } // error: ambiguous}int main(){    return(0);}

注意！下面这个不是Myers例子：

namespace A{    class T { };    void f(const T &) { }}class B // B is not a namespace but a class now!{    void f(const A::T &) { }    void g(A::T param) { f(param); } // OK};int main(){    return(0);}

这里B是一个class而不是一个namespace，没有任何二义性，当编译器发现一个名为f()的成员函数，它将不会试图使用Koenig查找规则来发现自由函数。

下面的例子可以更明确的说明这一点：

namespace A{    class T { };    void f(const T &) { }}class B // B is not a namespace but a class now!{    /*     * hide other functions named 'f'     * which in other domain    */    void f() { }    void g(A::T param) { f(param); } // no matching function};int main(){    return(0);}

再来看一个例子：

namespace A{    class T { };}void operator + (A::T, int) { }namespace B{    struct U { };    /*     * hide other functions named 'operator +'     * which in other domain    */    void operator + (U, int) { }    /* no match for 'operator +' */    void test(A::T param) { param + 1; }}int main(){    return(0);}

这种结果不是我们想要的，如果我们想让 param + 1 调用正确函数，

可以用域作用符(::)明确地指示我们要调用哪个函数：

namespace A{    class T { };}void operator + (A::T, int) { }namespace B{    struct U { };    /*     * hide other functions named 'operator +'     * which in other domain    */    void operator + (U, int) { }    /* call global 'operator +' explicitly */    void test(A::T param) { ::operator +(param, 1); } // ok}int main(){    return(0);}

或是用using声明：

namespace A{    class T { };}void operator + (A::T, int) { }namespace B{    struct U { };    /*     * hide other functions named 'operator +'     * which in other domain    */    void operator + (U, int) { }    /* using declaration of global 'operator +' */    using ::operator +;    void test(A::T param) { param + 1; } // ok}int main(){    return(0);}

但是，如果我们无法用上面的方法呢？

比如：test是namespace std中的一个函数，我们就没法用上面的两种方法来调用正确的operator +！

 

我们还有一个办法，那就是前面讲到的“Koenig查找”！如果我们将第一个 operator + 放入namespace A中，编译器就可以用“Koenig查找”找到正确的operator +！

namespace A{    class T { };    void operator + (A::T, int) { }}namespace B{    struct U { };    /*     * hide other functions named 'operator +'     * which in other domain    */    void operator + (U, int) { }    /*     * we need do nothing this time     * Koenig search (ADL) will get A::operator +    */    void test(A::T param) { param + 1; } // ok}int main(){    return(0);}

为了防止莫名其秒的函数隐藏给我们带来不必要的痛苦，我们应该将类的全部(包括与类类型相关的自由函数)，放入相同的名字空间！

 

下面的代码也可以：

class T { };void operator + (T, int) { }namespace B{    struct U { };    /*     * hide other functions named 'operator +'     * which in other domain    */    void operator + (U, int) { }    /*     * we need do nothing this time     * Koenig search (ADL) will get A::operator +    */    void test(T param) { param + 1; } // ok}int main(){    return(0);}

因为类T与我们都要的operator +定义在同一个文件中，也就是说它们其实是定义在同一个无名的名字空间中，所以，可以由“Koenig查找”找到这个operator +！