重载友元运算符<<用于类模板

你不能像这样声明一个朋友，你需要为它指定一个不同的模板类型。

template <typename SclassT>
friend ostream& operator<< (ostream & os, const D<SclassT>& rhs);

注意，这样它就不会遮蔽。定义SclassTclassT

template <typename SclassT>
ostream& operator<< (ostream & os, const D<SclassT>& rhs)
{
  // body..
}

这对我有用，没有任何编译器警告。

#include <iostream>
using namespace std;

template <class T>
T my_max(T a, T b)
{
  if(a > b)
    return a;
  else
    return b;
}

template <class classT>
class D
{
public:
  D(classT in)
    : d(in) {};

  bool operator>(const D& rhs) const {
    return (d > rhs.d);
  }

  classT operator=(const D<classT>& rhs);

  friend ostream& operator<< (ostream & os, const D& rhs) {
    os << rhs.d;
    return os;
  }

private:
  classT d;
};


int main()
{

  int i1 = 1;
  int i2 = 2;
  D<int> d1(i1);
  D<int> d2(i2);

  cout << my_max(d1,d2) << endl;
  return 0;
}

给你：

#include <cstdlib>
#include <iostream>
using namespace std;

template <class T>
T my_max(T a, T b)
{
   if(a > b)      
      return a;
   else
      return b;
}

template <class classT>
class D
{
public:
   D(classT in)
      : d(in) {};
   bool operator>(const D& rhs) const { return d > rhs.d;};
   classT operator=(const D<classT>& rhs);

   template<class classT> friend ostream& operator<< (ostream & os, const D<classT>& rhs);
private:
   classT d;
};

template<class classT> ostream& operator<<(ostream& os, class D<typename classT> const& rhs)
{
    os << rhs.d;
    return os;
}


int main()
{

   int i1 = 1;
   int i2 = 2;
   D<int> d1(i1);
   D<int> d2(i2);

   cout << my_max(d1,d2) << endl;
   return 0;
}

我认为你一开始就不应该交朋友。

您可以创建一个公共方法调用 print，如下所示（对于非模板类）：

std::ostream& MyClass::print(std::ostream& os) const
{
  os << "Private One" << privateOne_ << endl;
  os << "Private Two" << privateTwo_ << endl;
  os.flush();
  return os;
}

然后，在类之外（但在同一个命名空间中）

std::ostream& operator<<(std::ostream& os, const MyClass& myClass)
{
  return myClass.print(os);
}

我认为它应该也适用于模板类，但我还没有测试过。

这是那些具有相似但并不完全相同的不同方法的常见问题之一。这三种方法的不同之处在于你声明谁是你的函数的朋友，然后是你如何实现它。

性格外向

将模板的所有实例声明为友元。这是你所接受的答案，也是大多数其他答案所提出的。在这种方法中，您不必要地通过声明好友所有实例化来打开您的特定实例化。也就是说，可以访问 的所有内部。D<T>operator<<std::ostream& operator<<( std::ostream &, const D<int>& )D<double>

template <typename T>
class Test {
   template <typename U>      // all instantiations of this template are my friends
   friend std::ostream& operator<<( std::ostream&, const Test<U>& );
};
template <typename T>
std::ostream& operator<<( std::ostream& o, const Test<T>& ) {
   // Can access all Test<int>, Test<double>... regardless of what T is
}

内向的人

仅将插入运算符的特定实例声明为友元。 当插入运算符应用于自身时，它可能喜欢，但它不希望与 .D<int>std::ostream& operator<<( std::ostream&, const D<double>& )

这可以通过两种方式完成，简单的方法是 Berger 提出的@Emery，即内联运算符——出于其他原因，这也是一个好主意：

template <typename T>
class Test {
   friend std::ostream& operator<<( std::ostream& o, const Test& t ) {
      // can access the enclosing Test. If T is int, it cannot access Test<double>
   }
};

在第一个版本中，您不是为模板的每个实例创建模板化函数，而是创建非模板化函数。同样，差异是微妙的，但这基本上等同于手动添加：当你实例化时，以及当你使用 或任何其他类型实例化时，另一个类似的重载。operator<<Teststd::ostream& operator<<( std::ostream&, const Test<int>& )Test<int>Testdouble

第三个版本比较麻烦。在不内联代码的情况下，通过使用模板，您可以将模板的单个实例声明为类的好友，而无需向所有其他实例开放：

// Forward declare both templates:
template <typename T> class Test;
template <typename T> std::ostream& operator<<( std::ostream&, const Test<T>& );

// Declare the actual templates:
template <typename T>
class Test {
   friend std::ostream& operator<< <T>( std::ostream&, const Test<T>& );
};
// Implement the operator
template <typename T>
std::ostream& operator<<( std::ostream& o, const Test<T>& t ) {
   // Can only access Test<T> for the same T as is instantiating, that is:
   // if T is int, this template cannot access Test<double>, Test<char> ...
}

利用外向

第三种选择与第一种选择之间的微妙区别在于您对其他课程的开放程度。外向版本中滥用的一个例子是有人想要进入你的内部并这样做：

namespace hacker {
   struct unique {}; // Create a new unique type to avoid breaking ODR
   template <> 
   std::ostream& operator<< <unique>( std::ostream&, const Test<unique>& )
   {
      // if Test<T> is an extrovert, I can access and modify *any* Test<T>!!!
      // if Test<T> is an introvert, then I can only mess up with Test<unique> 
      // which is just not so much fun...
   }
}