嵌套在类模板中的类 X 的 operator<<(ostream&, X)

Question

这个编译和工作正常（非嵌套模板）：

#include <iostream>

template<typename T> class Z;

template <typename T> 
std::ostream& operator<< (std::ostream& os, const Z<T>&) {
    return (os << "Z");
}

template<typename T> class Z {
    friend std::ostream& operator<< <> (std::ostream& os, const Z&);
};

int main () {
    Z<int> z;
    std::cout << z << std::endl;
}

这个不能编译（gcc 4.4 和 gcc 4.6，在 03 和 0x 模式下）：

#include <iostream>

template<typename T> class Z;

template<typename T> 
std::ostream& operator<< (std::ostream& os, const typename Z<T>::ZZ&) {
    return (os << "ZZ!");
}

template <typename T> class Z {
  public:
    class ZZ {
        friend std::ostream& operator<< <> (std::ostream& os, const ZZ&);
    };
};


int main () {
    Z<int>::ZZ zz;
    std::cout << zz << std::endl;
}

错误信息如下所示：

error: template-id ‘operator<< <>’ for ‘std::ostream& operator<<(std::ostream&,
const Z<int>::ZZ&)’ does not match any template declaration
error: no match for ‘operator<<’ in ‘std::cout << zz’

0x模式下第二条错误信息不同，但含义相同。

有没有可能做我想做的事？

EDIT 显然，这里有一个 non-deduced context 的实例，它解释了错误消息。然而，问题仍然存在：我可以为嵌套在类模板中的类提供一个有效的 operator<< 吗？

Answer 1

这是函数的一般问题：

template <typename C>
void func(typename C::iterator i);

现在，如果我调用func(int*)，我应该使用C 的哪个值？

一般来说，你不能向后工作！许多不同的C 可能已经定义了一个内部类型iterator，它恰好是一组参数的int*。

在你的情况下，你的情况有点复杂：

template <typename T>
void func(typename Z<T>::ZZ const&);

但基本上这是同一个问题，Z<T> 是一个模板，而不是一个完整的类，并且您要求为此模板的内部类型 ZZ 创建一个函数。

假设我这样做：

template <typename T>
struct Z { typedef T ZZ; };

template <typename T>
struct Z<T const> { typedef T ZZ; };

注意：典型的迭代器，value_type 不是 const 限定的

那么，在调用func(int)时，我应该使用Z<int>还是Z<int const>？

这是不可演绎的。

因此整个事情被称为不可演绎的上下文，标准禁止它，因为没有合理的答案。

经验法则：对函数参数中的typename持怀疑态度。

注意：如果另一个参数已经确定了类型，它们是可以的，例如typename C::iterator find(C&, typename C::const_reference);，因为一旦推断出C，那么C::const_reference 可以毫无问题地使用

Answer 2

除了友元声明与操作符模板不匹配的问题（或许可以修复为）

class ZZ {
    template<class U>
    friend std::ostream& operator<<(std::ostream& os, const ZZ&);
};

您还遇到了“非推断上下文”的问题，这就是 Matthieu 所链接的内容。

在这个模板中

template<typename T> 
std::ostream& operator<< (std::ostream& os, const typename Z<T>::ZZ&) {
    return (os << "ZZ!");
}

编译器无法确定 T's you 参数将匹配的内容。如果您专注于某些类型，可能会有多个匹配项

template<>
class Z<long>
{
public:
    typedef double   ZZ;
};

template<>
class Z<bool>
{
 public:
    typedef double   ZZ;
};

现在，如果我尝试打印 double，T 可能是 bool 或 long。

如果不检查所有个可能的T，编译器就无法确定这一点，而且它不必这样做。它只是跳过您的运算符。

Answer 3

Matthieu 很好地解释了这个问题，但是在这种情况下可以使用一个简单的解决方法。 您可以使用friend声明在类中实现friend函数：

#include <iostream>

template <typename T> class Z {
public:
  class ZZ {
    friend std::ostream& operator<< (std::ostream& os, const ZZ&) {
      return os << "ZZ!";
    }
  };
};


int main () {
  Z<int>::ZZ zz;
  std::cout << zz << std::endl;
}

Answer 4

另一种技术是提供一个像钩子一样工作的离线类模板。

template <typename T> class ZZZ { 
  T &getDerived() { return static_cast<T&>(*this); }
  T const &getDerived() const { return static_cast<T const&>(*this); }

protected:
  ~ZZZ() { }
};

template <typename T> class Z {
  public:
    class ZZ : public ZZZ<ZZ> {
    };
};

template<typename ZZ> 
std::ostream& operator<< (std::ostream& os, const ZZZ<ZZ> &zzz) {
    ZZ const& zz = zzz.getDerived();
    /* now you can use zz */
    return (os << "ZZ!");
}

不过最好使用友元函数定义。但很高兴了解替代方案。