模板结构中的朋友运算符引发重新定义错误

Question

考虑这段代码：

template<typename T,typename K>
struct A{

   friend std::ostream& operator<<(std::ostream& out, K x) { 
      // Do some output 
      return out; 
   }

};

int main(){
   A<int,int> i;
   A<double,int> j;
}

它没有编译，因为A的两个实例化operator<<两次使用相同的签名，所以我收到这个错误：

test.cpp:26:25: error: redefinition of ‘std::ostream& operator<<(std::ostream&, int)’
    friend std::ostream& operator<<(std::ostream& out, K x) { return out; }
                         ^
test.cpp:26:25: error: ‘std::ostream& operator<<(std::ostream&, int)’ previously defined here

如何解决这个问题？当该运算符 可能 对两个不同的实例具有相同的签名时，如何在模板中拥有一个朋友运算符？如何在不触发重定义错误的情况下解决这个问题？

Answer 1

我真的不认为像这样宣布朋友有任何用处，但你可以这样做：

template<typename T, typename K>
struct A{
  template<typename L>
  friend std::ostream& operator<<(std::ostream& out, L const &x);
};

template<typename T>
std::ostream& operator<<(std::ostream& out, T const &x) {
  // ... 
  return out;
}

LIVE DEMO

编辑：

另一个可能更接近您想要的选项是：

template<typename T>
std::ostream& operator<<(std::ostream& out, T const &x);

template<typename T, typename K>
struct A{
  friend std::ostream& operator<<<K>(std::ostream& out, K const &x);
};

template<typename T>
std::ostream& operator<<(std::ostream& out, T const &x) { 
  // ...
  return out;
}

LIVE DEMO

但真的不知道你为什么想要这个。恕我直言，您的设计存在严重缺陷。

Answer 2

您的问题在以下方面有问题。

假设它是一个存根，并且您的类有一些私有的东西，因此它需要声明一个朋友，这样做的目的是该朋友在类本身的外部，但可以访问其中的私有内容。

在您的情况下，您将参数的流式函数声明为友元。没事儿。这意味着如果有人创建了一个 Bar 类并想要定义 Bar 的流式传输方式，他们的实现可以访问 A<T,Bar> 中任何类型 T 的任何内容。

您的模板与operator<<( ostream&, int) 的冲突实际上不是问题，因为编译器知道该选择哪一个。它总是会选择完全匹配的非模板而不是模板。您的问题是您有 2 个模板，编译器无法在它们之间进行选择，因为它们都同样有效。

也许这就是你真正想要实现的目标

template< typename X, typename Y >
struct A
{
   friend void a_print( std::ostream& Y const & ); // foo external function with Y as parameter, can access this
};

std::ostream & operator<<( std::ostream & out, Bar const& bar )
{
   a_print( out, bar );
   return out;
}

void a_print( Bar const& bar, std::ostream & out )
{
   // implement and call private members of A<Foo, Bar>
   return out;
}

您可以将流式传输模板设为好友，并使用特定实现实现该模板以供 Bar 流式传输。

Answer 3

将方法分解为基类：

template <typename K>
struct ABase
{
   friend std::ostream& operator<<(std::ostream& out, K x) { 
      // Do some output 
      return out; 
   }
};

template <typename T,typename K>
struct A : public ABase<K>
{};

Answer 4

如果你想流式传输 A 对象，正确的签名应该是

template<typename T,typename K>
struct A{

   friend std::ostream& operator<<(std::ostream& out, const A& x) { 
      // Do some output 
      return out; 
   }

};

获取您可以访问私人成员的A<T,K>，而不是K。

如果没有办法从 K 中得到 A（如果 K 是 int 则不可能），让 <<(ostream&,K) 成为 A 的朋友没有任何好处。