Comment diviser la définition de la fonction ami modèle dans la classe modèle?

Question

L'exemple suivant compile bien mais je ne peux pas comprendre comment séparer la déclaration et la définition de l'opérateur < <() est ce cas particulier.

Chaque fois que j'essaie de diviser l'ami de définition cause un problème et que gcc se plaint de l'opérateur < <() la définition doit prendre exactement un argument.

#include <iostream> 
template <typename T> 
class Test { 
    public: 
     Test(const T& value) : value_(value) {} 

     template <typename STREAM> 
     friend STREAM& operator<<(STREAM& os, const Test<T>& rhs) { 
      os << rhs.value_; 
      return os; 
     } 
    private: 
     T value_; 
}; 

int main() { 
    std::cout << Test<int>(5) << std::endl; 
} 

opérateur < <() est censé avoir un premier paramètre libre pour travailler avec différents types de flux de sortie (std :: Cout, std :: wcout ou boost :: asio :: :: ip tcp: : iostream). Le second paramètre devrait être lié à une version spécialisée de la classe environnante.

Test<int> x; 
some_other_class y; 

std::cout << x; // works 
boost::asio::ip::tcp::iostream << x; // works 

std::cout << y; // doesn't work 
boost::asio::ip::tcp::iostream << y; // works 

En outre en utilisant une fonction non-membre ne équivaut pas à diviser la définition et la déclaration parce que non-membres fonctions ne peuvent pas accéder attributs privés de la classe.

Answer 1

Le plus simple est sans doute de faire tous ces opérateurs de modèle amis:

#include <iostream> 
template <typename T> 
class Test 
{ 
    public: 
     Test(const T& value) : value_(value) {} 

     template <typename STREAM, typename U> 
     friend STREAM& operator<<(STREAM& os, const Test<U>& rhs); 

    private: 
     T value_; 
}; 

template <typename STREAM, typename T> 
STREAM& operator<<(STREAM& os, const Test<T>& rhs) 
{ 
    os << rhs.value_; 
    return os; 
} 

Answer 2

Ne devrait-il pas être défini en dehors de la classe?

template <typename T> 
class Test 
{ 
    ... 
    template <typename STREAM> 
    friend STREAM& operator<<(STREAM& os, const Test<T>& rhs); 
}; 

template <typename STREAM, typename T> 
STREAM& operator<<(STREAM& os, const Test<T>& rhs) 
{ 
    os << rhs.value_; 
    return os; 
} 

Answer 3

Le plus proche que je peux atteindre est

#include <iostream> 

template <typename T> 
class Test; 

template <typename STREAM, typename T> 
STREAM& operator<<(STREAM& os, const Test<T>& rhs); 

template <typename T> 
class Test { 
public: 
    Test(const T& value) : value_(value) {} 

    template <typename STREAM, typename U> 
    friend STREAM& operator<< (STREAM& os, const Test<U>& rhs); 

private: 
    T value_; 
}; 

template <typename STREAM, typename T> 
STREAM& operator<<(STREAM& os, const Test<T>& rhs) { 
    os << rhs.value_; 
    return os; 
} 

int main() { 
    std::cout << Test<int>(5) << std::endl; 
} 

qui déclare tout opérateur < < comme ami au lieu de seulement celui qui est paramétré par T. Le problème est qu'il n'est pas possible de spécialiser partiellement les fonctions. On aurait aimé utiliser

template <typename STREAM> 
friend STREAM& operator<< <STREAM, T> (STREAM& os, const Test<T>& rhs); 

mais cette syntaxe n'est pas valide. (Bien, et la spécialisation partielle ne peut pas être déclarée ami)

Answer 4

Le problème est que dans le code que vous présentez l'ami est une fonction modélisée paramétrée uniquement sur le premier type d'argument. C'est, pour chaque type d'instanciation T du modèle de classe (appeler mytype), vous déclarez une fonction de modèle gratuit:

template <typename STREAM> 
STREAM& operator<<(STREAM& os, Test<mytype> const & x); 

Le point important, il est que Test<mytype> est le instanciation particulier de Test avec l'argument de type mytype . Si vous voulez vraiment déclarer une fonction ami qui est modélisée dans le type de flux et le type d'instanciation du modèle Test, vous devez déclarer un ami avec deux arguments. D'autre part, je vous recommande de ne pas paramétrer operator<< sur le type de flux, et en même temps, de le définir dans les accolades de classe car il présente de légers avantages (les règles de recherche de nom sont légèrement différentes).

Answer 5

Pour chaque type instancié T de classe Test, un opérateur de fonction de gabarit < <() est exposé qui peut fonctionner sur différents types de flux. La fonction opérateur < <() a un premier paramètre libre mais un second paramètre fixe.

exemple:

Test<int> x; 
some_other_class y; 

std::cout << x; // works 
boost::asio::ip::tcp::iostream << x; // works 

std::cout << y; // doesn't work 
boost::asio::ip::tcp::iostream << y; // works 

C'est la façon dont la classe d'essai était censé fonctionner.