web-dev-qa-db-ja.com

テンプレートクラスのオーバーロードフレンド演算子<<

私はStackOverflow.comで私の問題に関するいくつかの質問を読みましたが、どれも私の問題を解決していないようです。または、私は間違っているかもしれません...オーバーロードされた_<<_は、インライン関数にすると機能します。しかし、私の場合、どのように機能させるのですか？

warning: friend declaration std::ostream& operator<<(std::ostream&, const D<classT>&)' declares a non-template function

warning: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning

/tmp/cc6VTWdv.o:uppgift4.cc:(.text+0x180): undefined reference to operator<<(std::basic_ostream<char, std::char_traits<char> >&, D<int> const&)' collect2: ld returned 1 exit status

コード：

_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;
   classT operator=(const D<classT>& rhs);

   friend ostream& operator<< (ostream & os, const D<classT>& rhs);
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;
}

template <class classT>
ostream& operator<<(ostream &os, const D<classT>& rhs)
{
   os << rhs.d;
   return os;
}
_
c++templatesoperator-overloadingfriendostream
52
starcorn

これは、よく似ているが実際には同じではないさまざまなアプローチを持つよくある質問の1つです。 3つのアプローチは、関数のフレンドであると宣言している人、および実装方法が異なります。

外向性

テンプレートのすべてのインスタンス化をフレンドとして宣言します。これはあなたが答えとして受け入れたものであり、また他のほとんどの答えが提案するものでもあります。このアプローチでは、すべての_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>& )とは何の関係もありません。

これは2つの方法で行うことができます。簡単な方法は@Emery Bergerが提案したように、演算子をインライン化することです。これは他の理由からも良い考えです。

_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<<_をnot作成するのではなく、Testテンプレートのインスタンス化ごとにテンプレート化されていない関数を作成します。繰り返しますが、違いは微妙ですが、これは基本的に手動で追加するのと同等です：_Test<int>_をインスタンス化するときにstd::ostream& operator<<( std::ostream&, const Test<int>& )とTestでdoubleをインスタンス化するときに別の同様のオーバーロードまたは他のタイプで。

3番目のバージョンはより面倒です。コードをインライン化せずに、テンプレートを使用すると、他のインスタンス化allを開かずに、テンプレートの単一のインスタンス化をクラスの友人として宣言できます。

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

外向性を利用する

この3番目のオプションと最初のオプションの微妙な違いは、他のクラスにどれだけ開放するかです。 extrovertバージョンでの不正使用の例は、内部へのアクセスを取得したい人で、これを行います。

_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...
   }
}
_
139
David Rodríguez - dribeas

そのような友人を宣言することはできません。別のテンプレートタイプを指定する必要があります。

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

SclassTをシャドウしないようにclassTに注意してください。定義するとき

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

これは、コンパイラーの警告なしで機能しました。

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

そもそも友達を作るべきではないと思います。

次のようなパブリックメソッド呼び出し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);
}

テンプレートクラスでも機能するはずだと思いますが、まだテストしていません。

0
Alessandro Teruzzi

どうぞ：

#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;
}
0
John Dibling