оператор перегрузки друга << для шаблона класса

Question

Я уже пару раз задал вопрос о моей проблеме в stackoverflow, и ни одна из них, похоже, не решила мою проблему. Или я, возможно, сделал это неправильно ... Перегруженный <<, если я ввожу его в встроенную функцию. Но как мне заставить его работать в моем случае?

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

Answer 1

Это один из тех часто задаваемых вопросов, которые имеют разные подходы, сходные, но не совсем одинаковые. Три подхода отличаются тем, кто вы объявляете себя другом вашей функции, а затем о том, как вы его реализуете.

экстраверт

Declare все конкретизации шаблона, как друзья. Это то, что вы приняли в качестве ответа, а также то, что предлагает большинство других ответов. В этом подходе вы безосновательно открываете свой конкретный экземпляр 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>&).

Это можно сделать двумя способами, простой способ быть в соответствии с предложением @Emery Berger, который встраивание оператор --which также является хорошей идеей, и по другим причинам:

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<<, а скорее не шаблонную функцию для каждого экземпляра шаблона Test. Опять же, разница тонкая, но это в основном эквивалентно добавлению вручную: std::ostream& operator<<(std::ostream&, const Test<int>&) при создании экземпляра Test<int> и другой подобной перегрузки при создании экземпляра Test с double или любым другим типом.

Третья версия является более громоздкой. Без встраивания кода, так и с использованием шаблона, вы можете объявить один экземпляр шаблона другого класса, не открывая себя все другой инстанциации:

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

Воспользовавшись 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... 
    } 
} 

Answer 2

Вы не можете объявить друга, как это, вам нужно указать другой тип шаблона для него.

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

Answer 3

Это работало для меня без каких-либо предупреждений компилятора.

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

Answer 4

Здесь вы идете:

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

Answer 5

Я думаю, что вы не должны делать друг в первую очередь.

Вы можете создать вызов печати общественный метод, что-то вроде этого (для не шаблонного класса):

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

Я думаю, что он должен работать и для класса шаблонов, но я еще не тестировал.