Cascada de operadores de entrada/salida en C++

Requisito previo: Sobrecarga de operadores en C++ , Tipos de sobrecarga de operadores

Cuando un objeto llama a una función de operador pasando un argumento y el valor devuelto de la función de operador llama a la siguiente función de operador en la misma expresión, se llama como una cascada de operadores. A continuación se muestran los ejemplos para la ilustración de las operaciones en cascada:

Programa 1:

// C++ program to illustrate the
// cascading operators
#include <iostream>
using namespace std;
 
// Height Class
class Height {
private:
    int feet, inches;
 
public:
    // Default Constructor
    Height()
    {
        feet = 0;
        inches = 0;
    }
 
    // Function to assign value to
    // the object of class Height
    void setData(int x, int y)
    {
        feet = x;
        inches = y;
    }
 
    // Function to print the object
    // of the class
    void showData()
    {
        cout << feet << "'" << inches;
    }
 
    // Function for overloading
    // of operator +
    Height operator+(Height H)
    {
        Height temp;
 
        // Add the feets
        temp.feet = feet + H.feet;
 
        // Add the inches
        temp.inches = inches + H.inches;
        return temp;
    }
 
    // Function to normalize the height
    // into proper terms of 1 feet
    // per 12 inches
    void normalize()
    {
        // Update the feets
        if (inches == 12 || inches > 12) {
            feet = feet + inches / 12;
        }
 
        // Update Inches
        inches = inches % 12;
    }
};
 
// Driver Code
int main()
{
    Height h1, h2, h3, h4;
 
    // Initialize the three heights
    h1.setData(5, 9);
    h2.setData(5, 2);
    h3.setData(6, 2);
 
    // Add all the heights using
    // cascading of operators
    h4 = h1 + h2 + h3;
 
    // Normalize the heights
    h4.normalize();
 
    // Print the height h4
    h4.showData();
 
    return 0;
}

Explicación:
en este código, la cascada del operador se lleva a cabo aquí:

h4 = h1 + h2 + h3;

Aquí, al principio, el objeto h1 llama al operador (+) y pasa h2 como argumento en la llamada a la función del operador y el valor devuelto de esta función del operador llama de nuevo al operador (+) y pasa h3 como argumento en la misma expresión, por último, el el valor devuelto de esta segunda función de operador se asigna en h4.

Programa 2: Los múltiples usos de los operadores de entrada o salida ( «>>» o «<<« ) en una declaración también es un ejemplo de cascada del operador de entrada/salida .

• cout es un objeto de la clase ostream predefinida .
• Hay varias funciones de operador de inserciones (» <<« ) definidas en la clase ostream para diferentes tipos de datos primitivos. Para los tipos de datos no primitivos, debe definirlos mediante la función de amigo .

A continuación se muestra el programa 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;
}

Aporte:

Producción:

Algunos puntos importantes sobre la cascada de operadores:

• No hay límite en la cascada de operadores en un programa.
• El operador << devuelve una referencia ostream y tiene una referencia ostream para el primer parámetro, mientras que el operador >> devuelve una referencia istream y tiene una referencia istream para el primer parámetro.
• El segundo parámetro para ambos operadores es siempre una referencia a una instancia de la clase para la cual el operador está sobrecargado.