Surcharger les opérateurs d'insertion et d'extraction en tant que modèles

Question

J'essaye de surcharger ostream et istream en tant qu'indépendant de la classe dans un modèle. J'ai regardé en ligne mais n'ai pas été en mesure de trouver beaucoup qui spécifie sur la surcharge de modèle, aussi ce que j'ai vu semble indiquer que c'est la manière de préparer ces charges. Il est évident que je suis très novice en programmation et j'apprécierais toute aide. Je vous remercie.

#include <stdio.h> 
#include<vector> 
#include<iostream> 
using namespace std; 
template<class T> 
class MyClass 

{ 
enter code here 
public: 
    MyClass(); 
    MyClass(const T& p_val1); 
    MyClass(const MyClass<T>& p_val1); 
    ~MyClass(); 
    MyClass<T>& operator=(MyClass<T>& rhs); 

    friend ostream& operator<<(ostream& lhs, const MyClass<T> &printme); 
    friend istream& operator>><T>(istream& lhs, MyClass<T>& readme); 

private: 
    T* m_val1; 

};

implémentation de l'ostream et de l'istream.

template<class T> 
ostream& operator<<(ostream&lhs, const MyClass<T>& printme) 
{ 
    lhs << printme.m_val1; 
    return lhs; 
} 
template<class T> 
istream& operator>>(istream& lhs, MyClass<T>& readme) 
{ 
    lhs >> *(readme.m_val1); 
    return lhs; 
} 

ici sont les erreurs

Undefined symbols for architecture x86_64: 
    "MyClass<int>::~MyClass()", referenced from: 
     _main in main.o 
    "operator<<(std::__1::basic_ostream<char, std::__1::char_traits<char> >&, MyClass<int> const&)", referenced from: 
     _main in main.o 
ld: symbol(s) not found for architecture x86_64 
clang: error: linker command failed with exit code 1 (use -v to see invocation) 

Fonction principale

MyClass<int> a(8); 
    MyClass<int> b(9); 
    cout << " Enter a value for the two types to be swapped: "; 
    cin >> a >> b; 
    cout << "Before swapping...\n"; 
    cout << "Object a's pointer member dereferences a value of:\t" << a << endl; 
    cout << "Object b's pointer member dereferences a value of:\t" << b << endl; 

Answer 1

Vous déclarez vos opérateurs, mais pas les définir. La définition du modèle n'est pas liée à celles de votre classe, car leur prototype est différent, d'où l'erreur de lien. Changer votre déclaration à ceci:

template <typename T, typename Trait> 
friend std::basic_ostream<T, Trait>& 
operator<< (std::basic_ostream<T, Trait>& out, const MyClass& c) 
{ 
    return out << c.my_val1; 
} 

template <typename T, typename Trait> 
friend std::basic_istream<T, Trait>& 
operator>> (std::basic_istream<T, Trait>& in, MyClass& c) 
{ 
    return in >> *(c.my_val1); 
} 

Notez que qu'il utilise std::basic_ostream et std::basic_istream, avec leur type respectif et trait de type. Il permet à tous les flux d'être utilisés, non seulement std::ostream et std::istream.