przeciążanie operatora przyjaciela << dla szablonu klasy

Question

Przeczytałem kilka pytań dotyczących mojego problemu na stackoverflow teraz i żaden z nich nie wydaje się rozwiązać mojego problemu. Albo może zrobiłem to źle ... Przeciążony <<, jeśli zrobię to w funkcji inline. Ale jak sprawić, żeby działało w moim przypadku?

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

Jest to jedno z najczęściej zadawanych pytań, które mają różne podejścia, które są podobne, ale nie do końca podobne. Te trzy podejścia różnią się tym, o kim deklarujesz, że jesteś przyjacielem swojej funkcji - a następnie o tym, jak ją realizujesz.

ekstrawertyk

zadeklarowania wszystkich dawałaby szablonu jako przyjaciół. To jest to, co zaakceptowaliście jako odpowiedź, a także to, co proponuje większość innych odpowiedzi. W tym podejściu niepotrzebnie otwierasz swoją konkretną instancję D<T>, deklarując znajomym wszystkie instancje operator<<. Oznacza to, że std::ostream& operator<<(std::ostream &, const D<int>&) ma dostęp do wszystkich elementów wewnętrznych 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 
} 

W introwertycy

wykazać tylko konkretnej instancji operatora wkładania jak listy znajomych. D<int> może lubić operatora wstawiania, gdy zostanie zastosowany do niego samego, ale nie chce mieć nic wspólnego z std::ostream& operator<<(std::ostream&, const D<double>&).

Można to zrobić na dwa sposoby, prosty sposób bycia jako @Emery Berger proponuje, który jest inline operator --which to również dobry pomysł z innych powodów:

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

W tej pierwszej wersji , jesteś , a nie tworząc szablonową, operator<<, ale raczej niesformowaną funkcję dla każdego wystąpienia szablonu Test. Znowu różnica jest subtelna, ale jest to zasadniczo równoznaczne z ręcznym dodawaniem: std::ostream& operator<<(std::ostream&, const Test<int>&) podczas tworzenia instancji Test<int> i innego podobnego przeciążenia podczas tworzenia Test z double lub z dowolnego innego typu.

Trzecia wersja jest bardziej uciążliwa. Bez inline kod i przy użyciu szablonu, można zadeklarować jeden konkretyzacji szablonu przyjacielem swojej klasie, nie otwierając sobie wszystkie inne dawałaby:

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

wykorzystując ekstrawertyk

Subtelna różnica między tą trzecią opcją a pierwszą polega na tym, ile otwierasz na inne klasy. Przykładem nadużycia w ekstrawertyk wersji byłby ktoś, który chce uzyskać dostęp do swoich wewnętrznych i robi to:

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

Nie można zadeklarować przyjaciela takiego, trzeba określić inny typ szablonu dla niego.

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

uwaga SclassT tak, że nie ma cienia classT. Podczas definiowania

Answer 3

To działało dla mnie bez ostrzeżenia kompilatora.

#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

Proszę bardzo:

#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

myślę, że nie powinno się znajomego w pierwszej kolejności.

Można utworzyć publiczną metodę połączenia drukować coś takiego (w przypadku braku klasy szablonu):

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

a następnie, poza klasą (ale w tej samej przestrzeni nazw)

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

Myślę, że powinien działać również dla klasy szablonów, ale jeszcze nie testowałem.