Surcharge d’opérateur d’insertion C ++ (<<)

Je travaille sur une affectation dans laquelle je dois surcharger l’opérateur d’insertion pour prendre un object 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 se comstack bien, mais l’opérateur surchargé n’est pas appelé, mais l’adresse simple de l’object me parvient simplement.

Il m’est interdit de modifier le code de l’appelant. Toute modification doit donc concerner la surcharge de l’opérateur.

Mon code tel qu’il est en ce moment:

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

Pour le moment, je veux juste m’assurer que l’opérateur surchargé est appelé. Je corrigerai le code de sortie une fois que je saurai que j’appelle le bon opérateur.

Le code d’appel:

 // create Node  * n = NULL; // code modifying n // display cout << "\t{ " << n << " }\n";

Notez que le paramètre type de pHead est une référence à non-const, const Node* est un pointeur non-const à const, le type de l’argument n est Node* (c’est-à-dire un pointeur non-const à non-const). Leur type ne correspond pas, Node* doit être converti en const Node* , qui est temporaire et ne peut pas être lié à une référence à non-const.

En bref, vous ne pouvez pas lier une référence à non-const à un object de type différent.

Mais la référence à const peut être liée à temporaire, vous pouvez donc changer le type de paramètre en référence à const:

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

Ou changez-le en valeur passée, Node* sera implicitement converti en const Node* lorsqu’il sera passé en argument. (Passer un pointeur par référence à const n’a pas beaucoup de sens.)

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

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

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

Le problème est que l’insert prend un paramètre de type const Node* , mais il est appelé avec un argument de type Node* ; il n’y a pas de conversion de T* en const T* . Donc, le “correctif” consiste à retirer le const du const d’insertion de stream.

Mais, comme indiqué dans un commentaire, avoir un inserteur qui prend un pointeur sur un type est une mauvaise idée. Cela devrait prendre un const Node& , comme tous les autres insérateurs du monde. Je suppose que ceci est une contrainte imposée par une cession; si c’est le cas, c’est idiot. Vous êtes mal enseigné.