Latest web development tutorials

C sobrecarga # operador

Você pode redefinir ou substituir o operador de built-in C #. Portanto, os programadores podem usar os operadores de tipo definido pelo usuário. operadores sobrecarregados estão tendo um nome de função especial, seguida pelooperador palavra-chave definição do símbolo do operador.E outras funções, operadores sobrecarregados tem um tipo de retorno e lista de parâmetros.

Por exemplo, considere a seguinte função: 

público operador Box estática + (Box b, Box c)
{
   caixa = new Box ();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   caixa de retornar;
}

A função acima é Box classe definida pelo usuário implementa o operador de adição (+). É a propriedade de dois objetos de caixa são adicionados, e os objetos de retorno de caixa adicional.

Sobrecarga de operador para conseguir

O programa a seguir demonstra a implementação completa: 

using System;

OperatorOvlApplication namespace
{
   classe Box
   {
      comprimento duplo privado; // comprimento largura dupla privado; // largura altura dupla privado; // altura public double getVolume ()
      {
         comprimento de retorno * largura * altura;
      }
      SetLength public void (duplo len)
      {
         length = len;
      }

      setBreadth public void (double BRE)
      {
         largura = bre;
      }

      setHeight public void (double hei)
      {
         height = hei;
      }
      // Sobrecarregado + operador à soma dos dois Box objetos operador Box public static + (Box b, Box c)
      {
         caixa = new Box ();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         caixa de retornar;
      }

   }

   Tester classe
   {
      static void Main (string [] args)
      {
         Box Box1 = new Box (); // declara Box1, tipo Box
         Box Box2 = new Box (); // declara Box2, tipo Box
         Box Box3 = new Box (); // declara Box3, tipo Box
         double volume = 0,0; // // Box1 volume de detalhamento Box1.setLength (6,0);
         Box1.setBreadth (7,0);
         Box1.setHeight (5.0);

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

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

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

         // Os dois objetos são adicionados Box3 = Box1 + Box2;

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

Quando o código acima é compilado e executado, ele produz os seguintes resultados: 

volume de Box1: 210
volume de box2: 1560
volume de Box3: 5400

operadores recarregáveis ​​e não-sobrecarregada

A tabela a seguir descreve a capacidade da sobrecarga C # operator:

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

Exemplos

Para a discussão acima, vamos estender o exemplo acima, os operadores mais sobrecarregados: 

using System;

OperatorOvlApplication namespace
{
    classe Box
    {
       comprimento duplo privado; // comprimento largura dupla privado; // largura altura dupla privado; // altura public double getVolume ()
       {
         comprimento de retorno * largura * altura;
       }
      SetLength public void (duplo len)
      {
          length = len;
      }

      setBreadth public void (double BRE)
      {
          largura = bre;
      }

      setHeight public void (double hei)
      {
          height = hei;
      }
      // Sobrecarregado + operador à soma dos dois Box objetos operador Box public static + (Box b, Box c)
      {
          caixa = new Box ();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          caixa de retornar;
      }
      
      == Operador bool static (LHS Box, rhs Box)
      {
          estatuto bool = false;
          if (lhs.length == rhs.length && lhs.height == rhs.height 
             && Lhs.breadth == rhs.breadth)
          {
              status = true;
          }
          status de retorno;
      }
      operador bool public static! = (LHS Box, rhs Box)
      {
          estatuto bool = false;
          Se (lhs.length! = rhs.length || lhs.height! = rhs.height 
              || Lhs.breadth! = Rhs.breadth)
          {
              status = true;
          }
          status de retorno;
      }
      operador bool public static <(LHS Box, rhs Box)
      {
          estatuto bool = false;
          if (lhs.length <rhs.length && lhs.height 
              <Rhs.height && lhs.breadth <rhs.breadth)
          {
              status = true;
          }
          status de retorno;
      }

      operador bool public static> (LHS Box, rhs Box)
      {
          estatuto bool = false;
          if (lhs.length> rhs.length && lhs.height 
              > Rhs.height && lhs.breadth> rhs.breadth)
          {
              status = true;
          }
          status de retorno;
      }

      operador bool public static <= (LHS Box, rhs Box)
      {
          estatuto bool = false;
          if (lhs.length <= rhs.length && lhs.height 
              <= Rhs.height && lhs.breadth <= rhs.breadth)
          {
              status = true;
          }
          status de retorno;
      }

      operador bool public static> = (LHS Box, RHS Box)
      {
          estatuto bool = false;
          if (lhs.length> = rhs.length && lhs.height 
             > = Rhs.height && lhs.breadth> = rhs.breadth)
          {
              status = true;
          }
          status de retorno;
      }
      public override ToString string ()
      {
          voltar String.Format ( "({0}, {1}, {2})", comprimento, largura, altura);
      }
   
   }
    
   Tester classe
   {
      static void Main (string [] args)
      {
        Box Box1 = new Box (); // declara Box1, tipo Box
        Box Box2 = new Box (); // declara Box2, tipo Box
        Box Box3 = new Box (); // declara Box3, tipo Box
        Box Box4 = new Box ();
        double volume = 0,0; // // Box1 volume de detalhamento Box1.setLength (6,0);
        Box1.setBreadth (7,0);
        Box1.setHeight (5.0);

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

       // Use o ToString sobrecarregado () exibe duas caixas Console.WriteLine ( "Box1: {0}", Box1.ToString ());
        Console.WriteLine ( "Box2: {0}", Box2.ToString ());
        
        // Volume de Box1 de volume = Box1.getVolume ();
        Console.WriteLine ( "volume de Box1: {0}", volume);

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

        // Os dois objetos são adicionados Box3 = Box1 + Box2;
        Console.WriteLine ( "Box3: {0}", Box3.ToString ());
        // Volume de Box3 de volume = Box3.getVolume ();
        Console.WriteLine ( "volume de Box3: {0}", volume);

        // Comparando as caixas
        Se (Box1> Box2)
          Console.WriteLine ( "Box1 superior a Box2");
        mais
          Console.WriteLine ( "box1 não mais de Box2");
        Se (Box1 <Box2)
          Console.WriteLine ( "Box1 inferior a Box2");
        mais
          Console.WriteLine ( "BOX1 não inferior a Box2");
        Se (Box1> = Box2)
          Console.WriteLine ( "Box1 maior do que ou igual Box2");
        mais
          Console.WriteLine ( "BOX1 não é maior do que ou igual Box2");
        Se (Box1 <= Box2)
          Console.WriteLine ( "Box1 menos Box2");
        mais
          Console.WriteLine ( "Box1 não menos Box2");
        Se (Box1! = Box2)
          Console.WriteLine ( "Box1 não igual a Box2");
        mais
          Console.WriteLine ( "Box1 igual Box2");
        Box4 = Box3;
        if (Box3 == Box4)
          Console.WriteLine ( "Box3 igual Box4");
        mais
          Console.WriteLine ( "Box3 não é igual Box4");

        Console.ReadKey ();
      }
    }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados: 

Caixa1: (6, 7, 5)
Box2: (12, 13, 10)
volume de Box1: 210
volume de box2: 1560
Box3: (18, 20, 15)
volume de Box3: 5400
Box1 Box2 não mais de
Caixa1 Box2 inferior
Caixa1 Box2 não é maior do que ou igual
Box1 Box2 menos
Caixa1 Box2 não igual
Box3 igual Box4