C# Sobrecarga de operadores

Puede redefinir o sobrecargar los operadores integrados en C#. Por lo tanto, los programadores también pueden usar operadores de tipos definidos por el usuario. Un operador sobrecargado es una función con un nombre especial, que se define mediante la palabra claveoperatorseguida del símbolo del operador. Igual que otras funciones, los operadores sobrecargados tienen un tipo de retorno y una lista de parámetros.

Por ejemplo, observe la siguiente función:

public static Box operator+ (Box b, Box c)
{
   Box box = new Box();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   return box;
}

La función anterior implementa el operador de suma (+) para la clase Box definida por el usuario. Suma las propiedades de dos objetos Box y devuelve el objeto Box resultante.

Implementación de la sobrecarga de operadores

El siguiente programa demuestra la implementación completa:

Ejemplo

using System;

namespace OperatorOvlApplication
{
   class Box
   {
      private double length;      // Longitud
      private double breadth;     // Ancho
      private double height;      // Altura

      public double getVolume()
      {
         return length * breadth * height;
      }
      public void setLength( double len )
      {
         length = len;
      }

      public void setBreadth( double bre )
      {
         breadth = bre;
      }

      public void setHeight( double hei )
      {
         height = hei;
      }
      // Sobrecargar el operador + para sumar dos objetos Box
      public static Box operator+ (Box b, Box c)
      {
         Box box = new Box();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         return box;
      }

   }

   class Tester
   {
      static void Main(string[] args)
      {
         Box Box1 = new Box();         // Declarar Box1, de tipo Box
         Box Box2 = new Box();         // Declarar Box2, de tipo Box
         Box Box3 = new Box();         // Declarar Box3, de tipo Box
         double volume = 0.0;          // Volumen

         // Detalles de Box1
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);

         // Detalles de Box2
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);

         // Volumen de Box1
         volume = Box1.getVolume();
         Console.WriteLine("Volumen de Box1: {0}", volume);

         // Volumen de Box2
         volume = Box2.getVolume();
         Console.WriteLine("Volumen de Box2: {0}", volume);

         // Sumar los dos objetos
         Box3 = Box1 + Box2;

         // Volumen de Box3
         volume = Box3.getVolume();
         Console.WriteLine("Volumen de Box3: {0}", volume);
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Box1 的体积： 210
Box2 的体积： 1560
Box3 的体积： 5400

Operadores sobrecargables y no sobrecargables

La siguiente tabla describe la capacidad de sobrecarga de operadores en C#:

OperadorDescripción
+, -, !, ~, ++, --Estos operadores unarios tienen un solo operando y pueden sobrecargarse.
+, -, *, /, %Estos operadores binarios tienen dos operandos y pueden sobrecargarse.
==, !=, <, >, <=, >=Estos operadores de comparación pueden sobrecargarse.
&&, ||Estos operadores lógicos condicionales no pueden sobrecargarse directamente.
+=, -=, *=, /=, %=Estos operadores de asignación no pueden sobrecargarse.
=, ., ?:, ->, new, is, sizeof, typeofEstos operadores no pueden sobrecargarse.

Ejemplo

Con base en la discusión anterior, ampliemos el ejemplo anterior sobrecargando más operadores:

Ejemplo

using System;

namespace OperatorOvlApplication
{
    class Box
    {
       private double length;      // Longitud
       private double breadth;     // Ancho
       private double height;      // Altura
     
       public double getVolume()
       {
         return length * breadth * height;
       }
      public void setLength( double len )
      {
          length = len;
      }

      public void setBreadth( double bre )
      {
          breadth = bre;
      }

      public void setHeight( double hei )
      {
          height = hei;
      }
      // Sobrecargar el operador + para sumar dos objetos Box
      public static Box operator+ (Box b, Box c)
      {
          Box box = new Box();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          return box;
      }
     
      public static bool operator == (Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length == rhs.length && lhs.height == rhs.height
             && lhs.breadth == rhs.breadth)
          {
              status = true;
          }
          return status;
      }
      public static bool operator !=(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length != rhs.length || lhs.height != rhs.height
              || lhs.breadth != rhs.breadth)
          {
              status = true;
          }
          return status;
      }
      public static bool operator <(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length < rhs.length && lhs.height
              < rhs.height && lhs.breadth < rhs.breadth)
          {
              status = true;
          }
          return status;
      }

      public static bool operator >(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length > rhs.length && lhs.height
              > rhs.height && lhs.breadth > rhs.breadth)
          {
              status = true;
          }
          return status;
      }

      public static bool operator <=(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length <= rhs.length && lhs.height
              <= rhs.height && lhs.breadth <= rhs.breadth)
          {
              status = true;
          }
          return status;
      }

      public static bool operator >=(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length >= rhs.length && lhs.height
             >= rhs.height && lhs.breadth >= rhs.breadth)
          {
              status = true;
          }
          return status;
      }
      public override string ToString()
      {
          return String.Format("({0}, {1}, {2})", length, breadth, height);
      }
   
   }
   
   class Tester
   {
      static void Main(string[] args)
      {
        Box Box1 = new Box();          // Declarar Box1, de tipo Box
        Box Box2 = new Box();          // Declarar Box2, de tipo Box
        Box Box3 = new Box();          // Declarar Box3, de tipo Box
        Box Box4 = new Box();
        double volume = 0.0;   // Volumen

        // Detalles de Box1
        Box1.setLength(6.0);
        Box1.setBreadth(7.0);
        Box1.setHeight(5.0);

        // Detalles de Box2
        Box2.setLength(12.0);
        Box2.setBreadth(13.0);
        Box2.setHeight(10.0);

       // Usar ToString() sobrecargado para mostrar los dos objetos
        Console.WriteLine("Box1： {0}", Box1.ToString());
        Console.WriteLine("Box2： {0}", Box2.ToString());
       
        // Volumen de Box1
        volume = Box1.getVolume();
        Console.WriteLine("Volumen de Box1: {0}", volume);

        // Volumen de Box2
        volume = Box2.getVolume();
        Console.WriteLine("Volumen de Box2: {0}", volume);

        // Sumar los dos objetos
        Box3 = Box1 + Box2;
        Console.WriteLine("Box3： {0}", Box3.ToString());
        // Volumen de Box3
        volume = Box3.getVolume();
        Console.WriteLine("Volumen de Box3: {0}", volume);

        //comparing the boxes
        if (Box1 > Box2)
          Console.WriteLine("Box1 es mayor que Box2");
        else
          Console.WriteLine("Box1 no es mayor que Box2");
        if (Box1 < Box2)
          Console.WriteLine("Box1 es menor que Box2");
        else
          Console.WriteLine("Box1 no es menor que Box2");
        if (Box1 >= Box2)
          Console.WriteLine("Box1 es mayor o igual que Box2");
        else
          Console.WriteLine("Box1 no es mayor o igual que Box2");
        if (Box1 <= Box2)
          Console.WriteLine("Box1 es menor o igual que Box2");
        else
          Console.WriteLine("Box1 no es menor o igual que Box2");
        if (Box1 != Box2)
          Console.WriteLine("Box1 no es igual a Box2");
        else
          Console.WriteLine("Box1 es igual a Box2");
        Box4 = Box3;
        if (Box3 == Box4)
          Console.WriteLine("Box3 es igual a Box4");
        else
          Console.WriteLine("Box3 no es igual a Box4");

        Console.ReadKey();
      }
    }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Box1： (6, 7, 5)
Box2： (12, 13, 10)
Box1 的体积： 210
Box2 的体积： 1560
Box3： (18, 20, 15)
Box3 的体积： 5400
Box1 不大于 Box2
Box1 小于 Box2
Box1 不大于等于 Box2
Box1 小于等于 Box2
Box1 不等于 Box2
Box3 等于 Box4
Otras extensiones