嵌套模板類的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) {} 
    }; 
};