Operador Sobrecarga del operador ‘<<‘ y ‘>>’ en una clase de lista enlazada

Requisito previo: Sobrecarga de operadores en C++ , Lista enlazada en C++

C++ viene con bibliotecas que brindan formas de realizar Input y Output . En C++, la entrada y la salida se realizan como una secuencia de bytes, también conocida como secuencias. Los flujos de entrada y salida son administrados por la biblioteca iostream. cin y cout son los objetos estándar para el flujo de entrada y el flujo de salida. 

Podemos sobrecargar los operadores ‘>>’ y ‘<<‘ para tomar entradas en una lista enlazada e imprimir el elemento en la lista enlazada en C++. Tiene la capacidad de proporcionar a los operadores un significado especial para un tipo de datos, esta capacidad se conoce como Sobrecarga de operadores . 

La sintaxis para sobrecargar un operador es:

returnType operator symbol (arguments)
{
   Operations...
} 

Sobrecarga del operador istream ‘>>’:  

istream& operator>>(istream& is, node*& head)
{
    // Function call to overload the ">>"
    // operator
    takeInput(head);
}

Explicación: 
el tipo de valor devuelto para la función anterior es una referencia al objeto istream. En el enunciado “ cin >> cabeza; “, cin es el primer parámetro y una referencia a la cabeza es el segundo parámetro de la función. La función anterior se llama cuando se ejecuta cualquier declaración de este tipo.

Sobrecargando el operador ostream ‘<<‘: 

ostream& operator<<(ostream& os, node* head)
{
    // Function call to overload the "<<"
    // operator
    print(head);
}

Explicación: 
el tipo de retorno de la función anterior es una referencia al objeto ostream. En la instrucción “ cout << head; “, cout es el primer parámetro, y una referencia a la cabeza es el segundo parámetro de la función. La función anterior se llama cuando se ejecuta cualquier declaración de este tipo.

Código para la sobrecarga del operador ‘<>’:

A continuación se muestra el código para la sobrecarga de los operadores ‘>>’ y ‘<<‘ , que toma un número N como entrada de forma continua e inserta el número N en la lista enlazada hasta que N = -1.

// C++ program to demonstrate the
// overloading of '<<' and '>>'
// operators
#include <iostream>
using namespace std;
 
// Class for each node object
// of the linked list
class node {
public:
    // Node of the linked list
    int data;
    node* next;
 
    // Constructor of node class
    node(int d)
    {
        data = d;
        next = NULL;
    }
};
 
// Insert a node at head of linked
// list
void insertAtHead(node*& head, int d)
{
    node* n = new node(d);
    n->next = head;
    head = n;
}
 
// Insert a node at tail of linked
// list
void insertAtTail(node* head, int data)
{
    // Make new node using
    // constructor
    node* n = new node(data);
    node* temp = head;
 
    // Traverse till we get to end of
    // the linked list
    while (temp->next != NULL)
        temp = temp->next;
 
    // Append the new node n at the end
    // of the linked list
    temp->next = n;
}
 
// Print the node at the linked list
void print(node* head)
{
    // Print the first Node
    if (head != NULL) {
        cout << head->data;
        head = head->next;
    }
 
    // Traverse till head traverse
    // till end
    while (head != NULL) {
        cout << "->" << head->data;
        head = head->next;
    }
}
 
// Function that takes continuous input
// until user enter -1 while initializing
// the linked list.
void takeInput(node*& head)
{
    int n;
    cin >> n;
 
    // If n is not equals to -1 insert
    // the node in the linked list
    while (n != -1) {
 
        // If head is NULL, insert at
        // the beginning of list
        if (head == NULL)
            insertAtHead(head, n);
        else
            insertAtTail(head, n);
        cin >> n;
    }
}
 
// Overloading the ostream operator '<<'
// to print the complete linked list from
// beginning
ostream& operator<<(ostream& os, node* head)
{
    print(head);
}
 
// Overloading the istream operator '>>'
// to take continuous input into the linked
// list until user inputs -1
istream& operator>>(istream& is, node*& head)
{
    takeInput(head);
}
 
// Driver Code
int main()
{
    // initialise head to NULL
    node* head = NULL;
 
    // Overloading of '>>' for inserting
    // element in the linked list
    cin >> head;
 
    // Overloading of '<<' for printing
    // element in the linked list
    cout << head;
    return 0;
}