嵌套模板类的C++非成员函数

Question

我一直在编写几个包含嵌套迭代器类的类模板，需要进行相等比较。我认为这是相当典型的，这种比较是通过非会员（和非朋友）operator==函数来执行的。在这样做的时候，我的编译器（我使用的是Mingw32 GCC 4.4，标志为-O3 -g -Wall）未能找到该函数，并且我用尽了可能的原因。

在下面相当大的代码块中有三个类：一个Base类，一个持有Base对象的Composed类和一个与Composed类相同的嵌套类，只不过它嵌套在Outer类中。非会员operator==功能分别提供。这些类以模板化和未模板化的形式（在它们各自的名称空间中），后者相当于前者专用于无符号整数。

在main中，比较了每个类的两个相同的对象。对于未定义的情况，没有问题，但对于模板化的情况，编译器无法找到operator==。这是怎么回事？

#include <iostream> 

namespace templated { 

template<typename T> 
class Base { 
    T t_; 
public: 
    explicit Base(const T& t) : t_(t) {} 

    bool 
    equal(const Base& x) const { 
    return x.t_==t_; 
    } 
}; 

template<typename T> 
bool 
operator==(const Base<T> &x, const Base<T> &y) { 
    return x.equal(y); 
} 

template<typename T> 
class Composed { 
    typedef Base<T> Base_; 
    Base_ base_; 
public: 
    explicit Composed(const T& t) : base_(t) {} 
    bool equal(const Composed& x) const {return x.base_==base_;} 
}; 

template<typename T> 
bool 
operator==(const Composed<T> &x, const Composed<T> &y) { 
    return x.equal(y); 
} 

template<typename T> 
class Outer { 
public: 
    class Nested { 
    typedef Base<T> Base_; 
    Base_ base_; 
    public: 
    explicit Nested(const T& t) : base_(t) {} 
    bool equal(const Nested& x) const {return x.base_==base_;} 
    }; 
}; 

template<typename T> 
bool 
operator==(const typename Outer<T>::Nested &x, 
    const typename Outer<T>::Nested &y) { 
    return x.equal(y); 
} 

} // namespace templated 

namespace untemplated { 

class Base { 
    unsigned int t_; 
public: 
    explicit Base(const unsigned int& t) : t_(t) {} 

    bool 
    equal(const Base& x) const { 
    return x.t_==t_; 
    } 
}; 

bool 
operator==(const Base &x, const Base &y) { 
    return x.equal(y); 
} 

class Composed { 
    typedef Base Base_; 
    Base_ base_; 
public: 
    explicit Composed(const unsigned int& t) : base_(t) {} 
    bool equal(const Composed& x) const {return x.base_==base_;} 
}; 

bool 
operator==(const Composed &x, const Composed &y) { 
    return x.equal(y); 
} 

class Outer { 
public: 
    class Nested { 
    typedef Base Base_; 
    Base_ base_; 
    public: 
    explicit Nested(const unsigned int& t) : base_(t) {} 
    bool equal(const Nested& x) const {return x.base_==base_;} 
    }; 
}; 

bool 
operator==(const Outer::Nested &x, 
    const Outer::Nested &y) { 
    return x.equal(y); 
} 

} // namespace untemplated 

int main() { 
    using std::cout; 
    unsigned int testVal=3; 
    { // No templates first 
    typedef untemplated::Base Base_t; 
    Base_t a(testVal); 
    Base_t b(testVal); 

    cout << "a=b=" << testVal << "\n"; 
    cout << "a==b ? " << (a==b ? "TRUE" : "FALSE") << "\n"; 

    typedef untemplated::Composed Composed_t; 
    Composed_t c(testVal); 
    Composed_t d(testVal); 

    cout << "c=d=" << testVal << "\n"; 
    cout << "c==d ? " << (c==d ? "TRUE" : "FALSE") << "\n"; 

    typedef untemplated::Outer::Nested Nested_t; 
    Nested_t e(testVal); 
    Nested_t f(testVal); 

    cout << "e=f=" << testVal << "\n"; 
    cout << "e==f ? " << (e==f ? "TRUE" : "FALSE") << "\n"; 
    } 
    { // Now with templates 
    typedef templated::Base<unsigned int> Base_t; 
    Base_t a(testVal); 
    Base_t b(testVal); 

    cout << "a=b=" << testVal << "\n"; 
    cout << "a==b ? " << (a==b ? "TRUE" : "FALSE") << "\n"; 

    typedef templated::Composed<unsigned int> Composed_t; 
    Composed_t c(testVal); 
    Composed_t d(testVal); 

    cout << "c=d=" << testVal << "\n"; 
    cout << "d==c ? " << (c==d ? "TRUE" : "FALSE") << "\n"; 

    typedef templated::Outer<unsigned int>::Nested Nested_t; 
    Nested_t e(testVal); 
    Nested_t f(testVal); 

    cout << "e=f=" << testVal << "\n"; 
    cout << "e==f ? " << (e==f ? "TRUE" : "FALSE") << "\n"; 
    // Above line causes compiler error: 
    // error: no match for 'operator==' in 'e == f' 
    } 

    cout << std::endl; 
    return 0; 
} 

Answer 1

这个问题与嵌套类与模板相当常见。

template <class T> 
struct Outer { struct Inner {}; }; 

template <class T> 
void increment(typename Outer<T>::Inner&) {} 

找不到increment函数。我认为编译器解决查找太困难了。

你可以尽管缓解这个问题，

namespace detail 
{ 
    template <class T> struct InnerImpl {}; 

    template <class T> void increment(InnerImpl&) {} 
} 

template <class T> 
struct Outer 
{ 
    typedef detail::InnerImpl<T> Inner; 
}; 

int main(int argc, char* argv[]) 
{ 
    Outer<int>::Inner inner; 
    increment(inner);   // works 
} 

滑稽，是不是？

作为一条经验法则，typename在自由方法的参数（不适用于结果类型）是一个红色的鲱鱼，似乎阻止自动论证扣除。

Answer 2

如果您没有重载运算符&，那么只需比较内存地址。没有必要这样做。

Answer 3

接受答案后，我考虑了如何以最少的努力来修复我的代码。有了这个问题的更清晰的概念，我从C++ FAQ中获得了新的灵感，并将非成员operator==合并到类定义中作为朋友函数。这听起来并不像听起来那么简单，因为提供equal()成员函数的原因是为了避免朋友的需要，但对于模板来说，好友函数具有允许函数定义保存在类体，从而避免查找问题。

template<typename T> 
class Outer { 
public: 
    class Nested { 
    typedef Base<T> Base_; 
    Base_ base_; 
    friend bool operator==(Nested const &x, Nested const &y) { 
     return x.base_==y.base_; 
    } 
    public: 
    explicit Nested(const T& t) : base_(t) {} 
    }; 
};