Opérateur surchargé<< pour la syntaxe ostream

Question

J'ai passé en revue d'anciens devoirs matériels d'un cours le semestre dernier.Il s'agissait d'une fonction d'impression donnée pour imprimer des objets de liste chaînée.Je ne comprends pas pourquoi l'opérateur surchargé prend deux paramètres et l'un étant un objet OS.Lorsque nous imprimions des objets réels de liste liée sur main.cpp, nous n'avions pas besoin de passer un objet OS.Aussi, pourquoi renvoie-t-il le système d'exploitation ?Pourquoi ne pouvons-nous pas simplement utiliser COUT au lieu de "OS <<"?

Merci!

template <class T>
void List<T>::print(ostream & os) const
{
    os << "<";
    ListNode * curr = head;
    while (curr != NULL) {
        os << " " << curr->data;
        curr = curr->next;
    }
    os << " >";
}



// overloaded operator<<
template <class T>
ostream & operator<<(ostream & os, const List<T> & list)
{
    list.print(os);
    return os;
}

Answer 1

Ainsi, la question a été posée et quelle est la base, je vais essayer de donner une réponse très simpliste (bien que plutôt informelle et non pédant).

Je ne comprends pas pourquoi l'opérateur surchargé prend deux paramètres et un être un objet OS

opérateur << est un opérateur binaire. Il a un côté gauche et un côté droit. Lorsque vous écrivez:

cout << 123;

Vous invoquez cet opérateur avec deux opérandes (arguments): «Cout» à gauche et un entier, '123', à droite.

Lorsque nous imprimions des objets de liste liés réels sur MAIN.CPP, nous n'avait pas besoin de passer un objet OS.

Votre fonction d'impression est une fonction de membre ou une exploitant d'une classe. Cela déduirait implicitement que le premier argument, croustillant, n'a pas besoin d'être explicitement adopté puisque vous avez déjà le "Ceci" pointeur pour travailler avec votre objet de liste. Ce n'est pas le cas avec les opérateurs non membres car vous n'avez pas de déduire implicitement «Cet objet» de travailler déjà pour l'opérande gauche à gauche.

Lorsque vous écrivez du code comme celui-ci:

my_list.print(cout);

Vous pouvez y penser comme en réalisant réellement deux arguments, «my_list» et «COUT». Même si vous ne l'écrivez pas explicitement, vous avez accès à «My_List» à travers «cela» avec ses membres. Ce n'est pas le cas si vous avez écrit la fonction d'impression en tant que non membre, comme:

template <class T>
void print(const List<T>& my_list, ostream& os);

C'est aussi le cas avec votre opérateur qui n'est pas une fonction membre.

Aussi, pourquoi est-ce que cela retourne au système d'exploitation?

retourner une référence à Ostream est ce qui nous permet d'écrire des déclarations telles que ceci:

cout << "hello " << "world";

Nous invoquons d'abord l'opérateur << (COUT, "Bonjour") qui nous donne ensuite une autre référence d'Ostream au travail avec laquelle nous nous permet ensuite de procéder à l'opérateur d'invocation << (COUT, "WORLD"). S'il est renvoyé sous vide, par exemple, cela ne nous permettrait pas d'invoquer cet opérateur deux fois dans une déclaration puisque nous tenterions de produire le «monde» avec le vide que l'opérande de gauche.

Pourquoi ne pouvons-nous pas simplement utiliser Cout au lieu de "OS" "?

COUT implémente essentiellement l'interface OSTREAM. Il en va de même pour Ofstream, Ostringstream et d'autres types de flux de sortie. En l'écrivant en termes d'interface de base requis et non de dérivé d'Ostream spécifique, vous autorisez le code que vous écrivez à fonctionner avec STDIO Streams, flux de fichiers, flux de flux et autres. Fondamentalement, cela rend votre code très général et réutilisable qui est quelque chose que vous devriez vous efforcer de faire quand la pratique. Vous en apprendrez plus sur ce sujet plus que vous abordez le concept de polymorphisme.

Answer 2

Parce que c'est une fonction globale non membre.Avec la version de la fonction membre, le premier paramètre est implicitement l'objet appelant, this.Cela signifie que votre classe doit toujours être à gauche.Avec la fonction non membre, c'est un paramètre explicite ;de cette façon, vous pouvez spécifier n'importe quel type et surcharger les opérateurs pour les classes pour lesquelles vous ne pouvez pas modifier la source (tant qu'au moins un paramètre est un type défini par l'utilisateur).

La raison pour laquelle vous utilisez os c'est pour qu'il fonctionne avec les flux de fichiers et tout (tout ce qui hérite de ostream), au lieu de simplement cout.

Il revient os pour que tu puisses faire plus operator<< appelle la valeur de retour.Cela permet le chaînage des opérateurs, comme w << x << y << z, ce qui équivaut à operator<<(operator<<(operator<<(w, x), y), z).Si tu reviens void ou quelque chose comme ça, tu devrais t'arrêter à w << x parce que vous ne pouvez rien faire avec la valeur de retour de void.

Answer 3

Je ne comprends pas pourquoi l'opérateur surchargé prend deux paramètres et l'un étant un objet système.Lorsque nous imprimions des objets de liste chaînée réels sur main.cpp, nous n'avions pas besoin de transmettre un objet os.

Oui tu peux:quand tu dis cout << x, tu passes cout et x à operator<<.

Aussi, pourquoi renvoie-t-il le système d'exploitation ?

Faire cout << x << y possible.Ceci est analysé comme (cout << x) << y, c'est à dire.il insère y dans la valeur de retour de cout << x.

Pourquoi ne pouvons-nous pas simplement utiliser cout au lieu de "os <<" ?

Parce que parfois, vous souhaitez sortir vers un autre flux que la sortie standard.

Answer 4

Lorsque nous imprimions des objets réels de liste liée sur main.cpp, nous n'avions pas besoin de passer un objet OS.

Oui tu peux..quelque chose comme cout << obj;, où cout est le os flux de sortie.

Aussi, pourquoi renvoie-t-il le système d'exploitation ?Pourquoi ne pouvons-nous pas simplement utiliser cout au lieu de "os <<" ?

Cela permet d'enchaîner : cout << obj << " " << obj2;

Pourquoi ne pouvons-nous pas simplement utiliser cout au lieu de "os <<" ?

Cela câblerait le flux de sortie, de sorte que vous ne pourriez pas écrire dans un fichier ou dans toute autre sortie.