Surcharge de l'opérateur d'insertion C++ (<<)

Je travaille sur une affectation dans laquelle je dois surcharger l'opérateur d'insertion pour prendre un objet Node. J'ai créé la fonction de surcharge d'opérateur en dehors de la définition de classe, mais dans le fichier node.h. Tout compile bien, mais l'opérateur surchargé n'est pas appelé, à la place je reçois simplement l'adresse de l'objet.Surcharge de l'opérateur d'insertion C++ (<<)

Il est interdit de modifier le code appelant, donc toute modification doit être apportée à la surcharge de l'opérateur.

Mon code tel qu'il est en ce moment:

/** OPERATOR << ***********************************/ 
template<class T> 
inline std::ostream & operator << (std::ostream & out, const Node <T> *& pHead) 
{ 
    out << "INCOMPLETE"; 
    return out; 
}

En ce moment, je veux juste assurer l'opérateur surchargé est appelé. Je vais corriger le code de sortie une fois que je sais que j'appelle le bon opérateur.

Le code d'appel:

// create 
Node <char> * n = NULL; 

// code modifying n 

// display 
cout << "\t{ " << n << " }\n";

Source

2016-10-21 ThomasNichols89

'Cout << * n,' serait une solution plus facile –

C'est vrai, mais comme il est dit, je suis incapable de modifier le code d'appel. – ThomasNichols89

désolé, manquez cette partie. –

Notez que le paramètre pHead 'le type d'une référence à la non-const, const Node<T>* est un pointeur non-const à const, l'argument n' type s est Node<T>* (soit un pointeur non-const à la non-const) . Leur type ne correspond pas, Node<T>* doivent être convertis en const Node<T>*, ce qui est temporaire et ne peut pas être lié à la non-const. En résumé, vous ne pouvez pas lier une référence à non-const à un objet de type différent.

Mais référence à const pourrait être lié à temporaire, de sorte que vous pouvez changer le type de paramètre de référence à const:

template<class T> 
inline std::ostream & operator << (std::ostream & out, const Node <T> * const & pHead) 
//                  ~~~~~

Ou changer pour passer par valeur, Node<T>* sera convertie implicitement const Node<T>* en passant comme argument. (Passage pointeur par référence à const ne fait pas beaucoup de sens.)

template<class T> 
inline std::ostream & operator << (std::ostream & out, const Node <T> * pHead)

Enfin, la surcharge operator<< avec le type de pointeur semble bizarre. La forme la plus commune avec le type défini par l'utilisateur serait:

template<class T> 
std::ostream & operator << (std::ostream & out, const Node <T> & pHead)

Source

2016-10-21 15:04:57 songyuanyao

Merci d'avoir clarifié les détails de l'utilisation de const et des types de référence. Le dernier bloc de code est l'endroit où j'ai commencé, mais le modérateur de la classe m'a informé qu'il avait besoin de prendre un pointeur. Le premier bloc de code que vous avez publié fonctionne très bien (pour cette tâche de toute façon.) Je vous garderai à l'esprit les conseils sur les meilleures pratiques pour aller de l'avant. – ThomasNichols89

Le problème est que l'introducteur prend un paramètre de type const Node<T>*, mais il est appelé avec un argument de type Node<T>*; il n'y a pas de conversion de T* à const T*. Le "correctif" consiste donc à supprimer le const de l'inséreur de flux. Mais, comme indiqué dans un commentaire, avoir un inséreur qui prend un pointeur vers un type est une mauvaise idée. Il devrait prendre un const Node<T>&, comme tous les autres inserters dans le monde. Je suppose que c'est une contrainte imposée par une cession; si c'est le cas, c'est idiot. Vous êtes mal enseigné.

Source

2016-10-21 14:53:10

Vous avez raison de dire que c'est une contrainte de la classe. Le cours a nous construire une classe Node, et quelques fonctions indépendantes. La semaine suivante, nous prenons la classe Node et ces fonctions et les regroupons dans la classe Doubly Linked List. Jusqu'à présent (5 semaines) toutes les autres structures de données ont utilisé la méthode commune que vous avez indiquée.Je crois que cette semaine est différente parce que la classe Node n'est pas un type de données abstrait complet. – ThomasNichols89

Surcharge de l'opérateur d'insertion C++ (<<)

Répondre

Questions connexes