Sobrecargar el operador de coma

 En C++ , podemos sobrecargar el operador de coma utilizando la sobrecarga de operadores . Por ejemplo: para “ Enviar la consulta X al servidor Y y poner el resultado en la variable Z” , el “y” hace el papel de la coma. El operador de coma (, ) se usa para aislar dos o más expresiones que se incluyen donde solo se espera una expresión. Cuando el conjunto de expresiones tiene que resolverse para los operandos, solo se considera la expresión más a la derecha.

Ejemplos:  

Entrada: x = (y = 5, y + 2)
Salida: x = 7, y = 5  
Explicación:
En la expresión anterior:
Primero asignaría el valor 5 a y, y luego asignaría y + 2 a la variable x.
Entonces, al final, ‘x’ contendría el valor 7, mientras que la variable ‘y’ contendría el valor 7.

Los Operadores Resistentes a la Sobrecarga son los siguientes:

• Operador de resolución de alcance (::)
• tamaño de()
• selector de miembros (.)
• selector de puntero de miembro(*)
• operador ternario(?:)

Sintaxis:

return_type class_name::operator op(argument_list)
{
    // cuerpo
    
}

donde,
1) return_type: es el tipo de valor devuelto por la función.
2) class_name: es el nombre de la clase.
3) op: es una función de operador donde op es el operador que se sobrecarga y el operador es la palabra clave.  

Reglas para la sobrecarga de operadores:

• Los operadores existentes solo se pueden sobrecargar, pero los nuevos operadores no se pueden sobrecargar.
• El operador sobrecargado contiene al menos un operando del tipo de datos definido por el usuario .
• La función de amigo no se puede usar para sobrecargar a ciertos operadores. Sin embargo, la función miembro se puede usar para sobrecargar esos operadores.
• Cuando los operadores unarios están sobrecargados a través de una función miembro, no toman argumentos explícitos, pero, si están sobrecargados por una función amiga, toman un argumento.
• Cuando los operadores binarios están sobrecargados a través de una función miembro, toman un argumento explícito, y si están sobrecargados a través de una función amiga, toman dos argumentos explícitos.

En el siguiente código, aunque el compilador evalúa cada expresión, los valores de la expresión de la izquierda se descartan. Finalmente, la función devuelve el valor de la operación de la mano derecha. Esto activa el operador de coma sobrecargado para que funcione de manera similar a su operación predeterminada.

// C++ program to illustrate the
// overloading the comma operator
#include <iostream>
using namespace std;
  
// Comma class
class comma {
    int x, y;
  
public:
    // Default Constructor
    comma() {}
  
    // Parameterized Constructor
    comma(int X, int Y)
    {
        x = X;
        y = Y;
    }
  
    // Function to display the value
    void display()
    {
        cout << "x=" << x << " ";
        cout << "y=" << y << " ";
    }
  
    comma operator+(comma ob2);
    comma operator, (comma ob2);
};
  
// Function to overload the + operator
comma comma::operator+(comma ob2)
{
    comma temp;
  
    // Update the value temp
    temp.x = ob2.x + x;
    temp.y = ob2.y + y;
  
    // Return the value temp
    return temp;
}
  
// Function to overload the, operator
comma comma::operator, (comma ob2)
{
    comma temp;
  
    // Update the value temp
    temp.x = ob2.x;
    temp.y = ob2.y;
  
    // Print the value
    cout << "x=" << ob2.x << " "
         << "y=" << ob2.y << endl;
  
    // Return the value temp
    return temp;
}
  
// Driver code
int main()
{
    // Initialize objects
    comma ob1(10, 20), ob2(5, 30), ob3(1, 1);
  
    ob1.display();
    ob2.display();
    ob3.display();
  
    cout << endl;
  
    ob1 = (ob2 + ob2, ob1, ob3);
  
    // Displays the value of
    // ob3 (Rightmost expression)
    ob1.display();
  
    return 0;
}

x=10 y=20 x=5 y=30 x=1 y=1 
x=10 y=20
x=1 y=1
x=1 y=1

A continuación se muestra otro ejemplo en el que el operador de coma (,) está sobrecargado en la clase denominada Coords3D . 

• La clase tiene 3 variables ocultas internas x, y, z .
• Método Get() que es el método de acceso para obtener los valores de x, y, z .
• La función de operador operator,() , que sobrecarga el operador ‘, ‘.

A continuación se muestra el programa para el mismo:

// C++ program to illustrate the
// overloading for comma operator
  
#include <iostream>
using namespace std;
  
// The class that defines the
// coordinates of a point in space
class Coords3D {
  
private:
    double x, y, z;
  
public:
    // Default Constructor
    Coords3D() { x = y = z = 0; }
  
    // Parameterized Constructor
    Coords3D(double x, double y,
             double z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }
  
    // Function for updating the value
    // ofx, y, and z
    void Get(double& x, double& y,
             double& z)
    {
        x = this->x;
        y = this->y;
        z = this->z;
    }
  
    // Function to overloaded the
    // operator, (comma)
    Coords3D operator, (Coords3D obj)
    {
        Coords3D tmp;
  
        // Update the value of temp
        tmp.x = obj.x;
        tmp.y = obj.y;
        tmp.z = obj.z;
  
        // Return the value of temp
        return tmp;
    }
};
  
// Driver Code
int main()
{
    double x, y, z;
  
    // Instances of class Coords3D
    Coords3D c1(1, 3, 5);
    Coords3D c2(2, 4, 6);
    Coords3D c3;
  
    // Invoke the operator function
    // c3.operator, (c2) into c3
    // is saved c2
    c3 = (c1, c2);
  
    // Get the value of x, y, z
    c3.Get(x, y, z);
  
    // Print x, y, and z
    cout << "x = " << x << endl;
    cout << "y = " << y << endl;
    cout << "z = " << z << endl;
  
    // Create another instance
    Coords3D c4(10, 15, 20);
  
    // c3 <= c4
    c3 = (c2, c1, c4);
  
    // Checking
    // x = 10, y = 15, z = 20
    c3.Get(x, y, z);
  
    cout << endl;
  
    // Print x, y, and z
    cout << "x = " << x << endl;
    cout << "y = " << y << endl;
    cout << "z = " << z << endl;
  
    return 0;
}

x = 2
y = 4
z = 6

x = 10
y = 15
z = 20