Überladen des Freundesoperators & lt; & lt; für die Vorlagenklasse

Dies ist einer jener Häufig gestellte Fragen, die verschiedene Ansätze, die ähnlich sind, aber nicht wirklich das gleiche. Die drei Ansätze unterscheiden sich in, wer Sie sind, deklarieren, ein Freund zu sein von Ihrer Funktion-und dann, wie Sie es umsetzen.

Der extrovertierte

Erklären, alle instantiierungen des template-als Freunde. Dies ist, was Sie angenommen haben, als Antwort, und auch, was die meisten der anderen Antworten vorschlagen. In diesem Ansatz werden Sie nicht unnötig öffnen Ihre spezielle Instanziierung D<T> durch deklarieren Freunde alle operator<< Instanziierungen. Das ist std::ostream& operator<<( std::ostream &, const D<int>& ) hat Zugriff auf alle Interna der 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
}

Der introvertierte

Nur erklären, eine bestimmte Instanziierung der insertion-operator als einen Freund. D<int> können, wie das insertion-operator bei Anwendung auf sich selbst, aber nicht wollen, etwas zu tun mit std::ostream& operator<<( std::ostream&, const D<double>& ).

Dies kann auf zwei Arten geschehen, die einfache Art und Weise sein, wie @Emery Berger vorgeschlagen, das inlining der Betreiber-das ist auch eine gute Idee aus anderen Gründen:

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>
   }
};

In dieser ersten version, Sie sind nicht erstellen einer Vorlagen - operator<< ist, sondern eher eine nicht-Vorlagen-Funktion für jede Instanziierung der Test Vorlage. Wieder, der Unterschied ist subtil, aber das ist im Grunde gleichwertig zum manuellen hinzufügen: std::ostream& operator<<( std::ostream&, const Test<int>& ) beim instanziieren Test<int>und eine ähnliche überlastung beim instanziieren Test mit double oder mit jedem anderen Typ.

Die Dritte version ist umständlicher. Ohne inlining den code, und mit der Verwendung einer Vorlage können Sie erklären, eine einzelne Instanziierung der Vorlage ein Freund der Klasse, ohne selbst zu öffnen, alle anderen instantiierungen:

//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> ...
}

Unter Ausnutzung der extrovertierte

Den subtilen Unterschied zwischen dieser Dritten option, und die erste ist, wie viel Sie öffnen, die für andere Klassen. Ein Beispiel für Missbrauch in der extrovertiert version wäre, dass jemand will, um Zugang zu Ihren Interna und tut:

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...
   }
}

InformationsquelleAutor der Antwort David Rodríguez - dribeas

Dieser arbeitete für mich, ohne compiler-Warnungen.

#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;
}

InformationsquelleAutor der Antwort EmeryBerger

Hier gehen Sie:

#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;
}

InformationsquelleAutor der Antwort John Dibling