Latest web development tutorials

C # sobrecarga del operador

Usted puede volver a definir o anular el operador incorporado en C #. Por lo tanto, los programadores pueden utilizar los operadores de tipo definido por el usuario. operadores sobrecargados están teniendo un nombre de función especial, seguido por el símbolo del operadoroperador de definición de palabras clave.Y otras funciones, operadores sobrecargados tienen un tipo de retorno y la lista de parámetros.

Por ejemplo, considere la siguiente función:

operador de la caja public static + (b Box, Box c)
{
   caja de la nueva caja = ();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   devuelva la caja;
}

La función anterior es Box clase definida por el usuario implementa el operador de suma (+). Es la propiedad se añaden dos objetos de la caja, y el retorno de los objetos de la caja añadió.

Sobrecarga de operadores para lograr

El programa siguiente muestra la implementación completa:

using System;

OperatorOvlApplication espacio de nombres
{
   clase Box
   {
      longitud doble privada; // longitud doble anchura privada; // ancho de doble altura privada; // altura pública getVolume doble ()
      {
         longitud de retorno * ancho * altura;
      }
      setLength public void (doble len)
      {
         = longitud len;
      }

      setBreadth public void (doble BRE)
      {
         anchura = bre;
      }

      setHeight public void (doble hei)
      {
         height = hei;
      }
      // Sobrecargado + operador a la suma de los dos objetos de cuadro operador de caja public static + (b Box, Box c)
      {
         caja de la nueva caja = ();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         devuelva la caja;
      }

   }

   probador de clase
   {
      static void main (String [] args)
      {
         Recuadro 1 = cuadro nuevo cuadro (); // Declarar Recuadro 1, tipo caja
         Caja Box2 = new Box (); // Declarar Box2, tipo caja
         Caja Caja3 = new Box (); // Declarar Caja3, Caja Tipo
         volumen doble = 0,0; // // Recuadro 1 volumen detalla Box1.setLength (6.0);
         Box1.setBreadth (7,0);
         Box1.setHeight (5,0);

         // Box2 detallando Box2.setLength (12,0);
         Box2.setBreadth (13,0);
         Box2.setHeight (10,0);

         // Volumen del volumen Recuadro 1 = Box1.getVolume ();
         Console.WriteLine ( "volumen Recuadro 1: {0}", volumen);

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

         // Los dos objetos se añaden Caja3 = Recuadro 1 + Box2;

         // Volumen Caja3 del volumen = Box3.getVolume ();
         Console.WriteLine ( "volumen Caja3: {0}", volumen);
         Console.ReadKey ();
      }
   }
}

Cuando el código se compila y ejecuta, produce los siguientes resultados:

box1 volumen: 210
volumen caja2: 1560
volumen box3: 5400

operadores recargables y no sobrecargada

La siguiente tabla describe la capacidad de la sobrecarga del operador C #:

运算符描述
+, -, !, ~, ++, --这些一元运算符只有一个操作数,且可以被重载。
+, -, *, /, %这些二元运算符带有两个操作数,且可以被重载。
==, !=, <, >, <=, >=这些比较运算符可以被重载。
&&, ||这些条件逻辑运算符不能被直接重载。
+=, -=, *=, /=, %=这些赋值运算符不能被重载。
=, ., ?:, ->, new, is, sizeof, typeof这些运算符不能被重载。

Ejemplos

Para la discusión anterior, vamos a ampliar el ejemplo anterior, los operadores más sobrecargados:

using System;

OperatorOvlApplication espacio de nombres
{
    clase Box
    {
       longitud doble privada; // longitud doble anchura privada; // ancho de doble altura privada; // altura pública getVolume doble ()
       {
         longitud de retorno * ancho * altura;
       }
      setLength public void (doble len)
      {
          = longitud len;
      }

      setBreadth public void (doble BRE)
      {
          anchura = bre;
      }

      setHeight public void (doble hei)
      {
          height = hei;
      }
      // Sobrecargado + operador a la suma de los dos objetos de cuadro operador de caja public static + (b Box, Box c)
      {
          caja de la nueva caja = ();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          devuelva la caja;
      }
      
      == Operador public static bool (izda Box, lado derecho de la caja)
      {
          estado bool = false;
          si (lhs.length == == rhs.length && lhs.height rhs.height 
             && Lhs.breadth == rhs.breadth)
          {
              estado = true;
          }
          estado de su salida;
      }
      public static bool operador! = (izda Box, lado derecho de la caja)
      {
          estado bool = false;
          si (lhs.length! = || rhs.length lhs.height! = rhs.height 
              || Lhs.breadth! = Rhs.breadth)
          {
              estado = true;
          }
          estado de su salida;
      }
      public static bool operador <(izda Box, lado derecho de la caja)
      {
          estado bool = false;
          si (lhs.length <&& rhs.length lhs.height 
              <&& Rhs.height lhs.breadth <rhs.breadth)
          {
              estado = true;
          }
          estado de su salida;
      }

      operador public static bool> (izda Box, lado derecho de la caja)
      {
          estado bool = false;
          si (lhs.length> rhs.length && lhs.height 
              > Rhs.height && lhs.breadth> rhs.breadth)
          {
              estado = true;
          }
          estado de su salida;
      }

      public static bool operador <= (izda Box, lado derecho de la caja)
      {
          estado bool = false;
          si (lhs.length <= rhs.length && lhs.height 
              <= Rhs.height && lhs.breadth <= rhs.breadth)
          {
              estado = true;
          }
          estado de su salida;
      }

      public static bool operador> = (izda Box, lado derecho de la caja)
      {
          estado bool = false;
          si (lhs.length> = rhs.length && lhs.height 
             > = Rhs.height && lhs.breadth> = rhs.breadth)
          {
              estado = true;
          }
          estado de su salida;
      }
      public override String toString ()
      {
          String.Format ( "({0}, {1}, {2})", longitud, anchura, altura) de regreso;
      }
   
   }
    
   probador de clase
   {
      static void main (String [] args)
      {
        Recuadro 1 = cuadro nuevo cuadro (); // Declarar Recuadro 1, tipo caja
        Caja Box2 = new Box (); // Declarar Box2, tipo caja
        Caja Caja3 = new Box (); // Declarar Caja3, Caja Tipo
        Caja box4 = new Box ();
        volumen doble = 0,0; // // Recuadro 1 volumen detalla Box1.setLength (6.0);
        Box1.setBreadth (7,0);
        Box1.setHeight (5,0);

        // Box2 detallando Box2.setLength (12,0);
        Box2.setBreadth (13,0);
        Box2.setHeight (10,0);

       // Utilizar el ToString () sobrecargados muestra dos cuadros Console.WriteLine ( "Cuadro1: {0}", Box1.ToString ());
        Console.WriteLine ( "Box2: {0}", Box2.ToString ());
        
        // Volumen del volumen Recuadro 1 = Box1.getVolume ();
        Console.WriteLine ( "volumen Recuadro 1: {0}", volumen);

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

        // Los dos objetos se añaden Caja3 = Recuadro 1 + Box2;
        Console.WriteLine ( "Caja3: {0}", Box3.ToString ());
        // Volumen Caja3 del volumen = Box3.getVolume ();
        Console.WriteLine ( "volumen Caja3: {0}", volumen);

        // La comparación de las cajas
        si (Recuadro 1> Box2)
          Console.WriteLine ( "Cuadro1 mayor que Box2");
        otro
          Console.WriteLine ( "box1 no más de Box2");
        si (Recuadro 1 <Box2)
          Console.WriteLine ( "Cuadro1 menos de Box2");
        otro
          Console.WriteLine ( "box1 no menos de Box2");
        si (Recuadro 1> = Box2)
          Console.WriteLine ( "Box1 mayor o igual Box2");
        otro
          Console.WriteLine ( "box1 no mayor que o igual Box2");
        si (Recuadro 1 <= Box2)
          Console.WriteLine ( "Cuadro1 menos Box2");
        otro
          Console.WriteLine ( "Cuadro1 no menor Box2");
        si (Recuadro 1! = Box2)
          Console.WriteLine ( "Cuadro1 no es igual Box2");
        otro
          Console.WriteLine ( "Cuadro1 igual Box2");
        Box4 = Caja3;
        si (== Caja3 box4)
          Console.WriteLine ( "Caja3 igual box4");
        otro
          Console.WriteLine ( "Caja3 no es igual box4");

        Console.ReadKey ();
      }
    }
}

Cuando el código se compila y ejecuta, produce los siguientes resultados:

Box1: (6, 7, 5)
Box2: (12, 13, 10)
box1 volumen: 210
volumen caja2: 1560
Box3: (18, 20, 15)
volumen box3: 5400
Box1 Box2 no más de
Box1 Box2 menos de
Box1 Box2 no es mayor que o igual
Box1 Box2 menos
Box1 Box2 no igual
Box3 igual box4