Latest web development tutorials

C # overloading degli operatori

È possibile ridefinire o sovrascrivere l'operatore built-in C #. Pertanto, i programmatori possono utilizzare gli operatori tipo definito dall'utente. operatori di overload stanno avendo un nome di funzione speciale, seguitodall'operatore parola chiave definizione di simbolo dell'operatore.E altre funzioni, operatori overload hanno un tipo di ritorno e lista dei parametri.

Ad esempio, si consideri la seguente funzione: 

operatore Box public static + (Box B, casella C)
{
   Box Box = new Box ();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   scatola di tornare;
}

La funzione di cui sopra è definita dall'utente classe Box implementa l'operatore di addizione (+). E 'di proprietà di due oggetti di sicurezza vengono aggiunti, e gli oggetti di ritorno Box aggiunto.

Overloading degli operatori di raggiungere

Il seguente programma illustra l'implementazione completa: 

using System;

namespace OperatorOvlApplication
{
   classe Box
   {
      lunghezza doppia privato; // lunghezza doppia largo privato; // larghezza doppia altezza privato; // altezza public double getVolume ()
      {
         lunghezza ritorno * la larghezza * altezza;
      }
      SetLength public void (doppia len)
      {
         lunghezza = len;
      }

      setBreadth public void (doppia BRE)
      {
         ampiezza = bre;
      }

      setHeight public void (doppia hei)
      {
         height = hei;
      }
      // Overload + operatore alla somma dei due Box oggetti Box operatore public static + (Box B, casella C)
      {
         Box Box = new Box ();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         scatola di tornare;
      }

   }

   classe Tester
   {
      static void Main (string [] args)
      {
         Box Box1 = new Box (); // dichiarare Box1, tipo Box
         Box Box2 = new Box (); // dichiarare Box2, tipo Box
         Box box3 = new Box (); // dichiarare box3, tipo Box
         doppio volume = 0.0; // // Box1 volume che descrive Box1.setLength (6.0);
         Box1.setBreadth (7.0);
         Box1.setHeight (5.0);

         // Box2 dettagli Box2.setLength (12.0);
         Box2.setBreadth (13,0);
         Box2.setHeight (10.0);

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

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

         // I due oggetti vengono aggiunti box3 = Box1 + Box2;

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

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

Volume Box1: 210
Volume Box2: 1560
Volume box3: 5400

operatori ricaricabile e non sovraccaricato

La seguente tabella descrive la capacità del sovraccarico C # operator:

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

Esempi

Per la discussione di cui sopra, cerchiamo di estendere l'esempio precedente, gli operatori più overload: 

using System;

namespace OperatorOvlApplication
{
    classe Box
    {
       lunghezza doppia privato; // lunghezza doppia largo privato; // larghezza doppia altezza privato; // altezza public double getVolume ()
       {
         lunghezza ritorno * la larghezza * altezza;
       }
      SetLength public void (doppia len)
      {
          lunghezza = len;
      }

      setBreadth public void (doppia BRE)
      {
          ampiezza = bre;
      }

      setHeight public void (doppia hei)
      {
          height = hei;
      }
      // Overload + operatore alla somma dei due Box oggetti Box operatore public static + (Box B, casella C)
      {
          Box Box = new Box ();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          scatola di tornare;
      }
      
      static bool operator == pubblico (ss Box, dx Box)
      {
          Stato bool = false;
          if (lhs.length == rhs.length && lhs.height == rhs.height 
             && Lhs.breadth == rhs.breadth)
          {
              Stato = true;
          }
          restituire lo stato;
      }
      bool operator public static! = (ss di sicurezza, sd Box)
      {
          Stato bool = false;
          if (lhs.length! = rhs.length || lhs.height! = rhs.height 
              || Lhs.breadth! = Rhs.breadth)
          {
              Stato = true;
          }
          restituire lo stato;
      }
      operatore pubblico bool static <(ss Box, dx Box)
      {
          Stato bool = false;
          if (lhs.length <rhs.length && lhs.height 
              <Rhs.height && lhs.breadth <rhs.breadth)
          {
              Stato = true;
          }
          restituire lo stato;
      }

      operatore pubblico bool statico> (ss Box, dx Box)
      {
          Stato bool = false;
          if (lhs.length> rhs.length && lhs.height 
              > Rhs.height && lhs.breadth> rhs.breadth)
          {
              Stato = true;
          }
          restituire lo stato;
      }

      operatore pubblico bool static <= (ss Box, dx Box)
      {
          Stato bool = false;
          if (lhs.length <= rhs.length && lhs.height 
              <= Rhs.height && lhs.breadth <= rhs.breadth)
          {
              Stato = true;
          }
          restituire lo stato;
      }

      operatore pubblico bool statico> = (ss Box, dx Box)
      {
          Stato bool = false;
          if (lhs.length> = rhs.length && lhs.height 
             > = Rhs.height && lhs.breadth> = rhs.breadth)
          {
              Stato = true;
          }
          restituire lo stato;
      }
      public override stringa di ToString ()
      {
          tornare String.Format ( "({0}, {1}, {2})", lunghezza, larghezza, altezza);
      }
   
   }
    
   classe Tester
   {
      static void Main (string [] args)
      {
        Box Box1 = new Box (); // dichiarare Box1, tipo Box
        Box Box2 = new Box (); // dichiarare Box2, tipo Box
        Box box3 = new Box (); // dichiarare box3, tipo Box
        Box Box4 = new Box ();
        doppio volume = 0.0; // // Box1 volume che descrive Box1.setLength (6.0);
        Box1.setBreadth (7.0);
        Box1.setHeight (5.0);

        // Box2 dettagli Box2.setLength (12.0);
        Box2.setBreadth (13,0);
        Box2.setHeight (10.0);

       // Utilizza il ToString sovraccarico () mostra due scatole Console.WriteLine ( "Box1: {0}", Box1.ToString ());
        Console.WriteLine ( "Box2: {0}", Box2.ToString ());
        
        // Volume di Box1 di volume = Box1.getVolume ();
        Console.WriteLine ( "Volume Box1: {0}", volume);

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

        // I due oggetti vengono aggiunti box3 = Box1 + Box2;
        Console.WriteLine ( "box3: {0}", Box3.ToString ());
        // Volume di box3 di volume = Box3.getVolume ();
        Console.WriteLine ( "Volume box3: {0}", volume);

        // Confrontando le scatole
        if (Box1> Box2)
          Console.WriteLine ( "Box1 maggiore di Box2");
        altro
          Console.WriteLine ( "box1 non più di Box2");
        if (Box1 <Box2)
          Console.WriteLine ( "Box1 meno di Box2");
        altro
          Console.WriteLine ( "box1 non inferiore a Box2");
        if (Box1> = Box2)
          Console.WriteLine ( "Box1 maggiore o uguale Box2");
        altro
          Console.WriteLine ( "box1 non maggiore o uguale Box2");
        if (Box1 <= Box2)
          Console.WriteLine ( "Box1 meno Box2");
        altro
          Console.WriteLine ( "Box1 non meno Box2");
        if (Box1! = Box2)
          Console.WriteLine ( "Box1 non uguale Box2");
        altro
          Console.WriteLine ( "Box1 pari Box2");
        Box4 = box3;
        if (box3 == Box4)
          Console.WriteLine ( "box3 pari Box4");
        altro
          Console.WriteLine ( "box3 non uguale Box4");

        Console.ReadKey ();
      }
    }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

Box1: (6, 7, 5)
Box2: (12, 13, 10)
Volume Box1: 210
Volume Box2: 1560
Box3: (18, 20, 15)
Volume box3: 5400
Box1 Box2 non più di
Box1 Box2 meno
Box1 Box2 non è maggiore o uguale
Box1 Box2 meno
Box1 Box2 non uguale
Box3 pari Box4