classe de modèles et extraction d'insertion surchargés

Question

Comment est-ce que je peux surcharger l'opérateur d'insertion (< <) et/ou d'extraction (>>) dans une classe de modèle SANS le faire en ligne. Je voudrais avoir l'opérateur < ou >> en tant que classe d'ami. Je sais comment faire inline exemple de ligne dans une classe de matrice

friend ostream& operator<<(ostream& ostr, const Matrix<T>& inputMatrix) 
{ 
    ... 
    // create the ostr 
    return ostr; 
} 

mais je voudrais avoir le code en dehors de la définition de templateclass. Après le nom de la fonction, je l'ai fait mais quand j'ai essayé d'installer une matrice de type SOMETYPE, il m'a donné une erreur qu'il ne savait pas comment extraire ou insérer pour ce type.

Answer 1

Si vous voulez vraiment définir l'opérateur à l'extérieur et se lier d'amitié que l'instanciation de l'opérateur qui coïncide dans le type avec ce modèle instanciation, la syntaxe correcte est:

template <typename T> class test; // forward declare template class 
template <typename T>    // forward declare the templated operator 
std::ostream& operator<<(std::ostream&, test<T> const &); 

template <typename T> 
class test {      // define the template 
    friend std::ostream& operator<< <T>(std::ostream&, test<T> const &); // befriend 
}; 
template <typename T>    // define the operator 
std::ostream& operator<<(std::ostream& o, test<T> const &) { 
    return o; 
} 

Dans la plupart des cas, il ne vaut pas les tracas de Tirez la définition hors de la classe, sachant que vous devez toujours le fournir dans un en-tête et le travail supplémentaire requis.

Notez également qu'il existe de légères différences pour le compilateur en ce qui concerne la recherche. Dans le cas où la fonction est inline dans la définition de la classe, le compilateur ne trouvera pas cette fonction sauf si l'un des arguments est réellement du type du template, donc il réduit efficacement la visibilité et la quantité de travail que le compilateur doit faire (si le modèle operator<< est défini en dehors de la classe, le compilateur le trouvera comme candidat pour la résolution de surcharge dans tous les endroits où il trouve a << b, seulement pour le rejeter dans tous les cas où le second argument n'est pas test<T> (et il montrera l'opérateur basé sur le modèle en tant que candidat dans tous les messages d'erreur où il ne peut pas correspondre operator<<, qui est déjà une liste assez longue.)

Answer 2

Placez le code dans l'en-tête, en dehors de la définition de classe. Ou placez-le dans un fichier .tcc et incluez-le au bas de l'en-tête.

Answer 3

Essayez quelque chose comme:

template <typename T> class Matrix; 
template <typename T> std::ostream& operator<<(std::ostream& ostr, const Matrix<T>& m); 

template <Typename T> 
class Matrix 
{ 
    public: 

     friend ostream& operator<< <T> (ostream& ostr, const Matrix<K>& inputMatrix); 
}; 

// This must be in the same translation unit as the class definition! 
template<typename T> 
ostream& operator<<(ostream& ostr, const Matrix<T>& inputMatrix) 
{ 
    // ... 
    return ostr; 
} 

Translation unit reference

re-re-modifié pour les commentaires adressés par aschepler et dribeas.