Latest web development tutorials

C # przeciążanie operatora

Można zmienić lub zastąpić wbudowany operatora C #. Dlatego programiści mogą korzystać z operatorów typu zdefiniowanego przez użytkownika. Przeciążone operatorzy mają specjalną nazwę funkcji, a następnie definicji symbolu operatora Hasłooperatora.I inne funkcje, przeciążone operatory mają typ zwracany oraz listę parametrów.

Na przykład, rozważmy następującą funkcję: 

public static Operator Box + (b Box, Box c)
{
   box = new Box ();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   pole powrócić;
}

Powyższa funkcja jest definiowana przez użytkownika klasy Box realizuje operatora dodawania (+). To jest własnością dwóch obiektów Box są dodawane i dodaniu obiektów skrzynce zwrotu.

Operator przeciążenie osiągnąć

Poniższy program pokazuje kompletną implementację: 

using System;

nazw OperatorOvlApplication
{
   Klasa Box
   {
      prywatne długość dwukrotnie; // Długość prywatny pokój wszerz; // szerokość prywatne podwójna wysokość; // wysokość publicznej podwójne getVolume ()
      {
         Długość powrotu * szerokość * wysokość;
      }
      public void setlength (podwójne len)
      {
         długość = len;
      }

      public void setBreadth (podwójne wyl)
      {
         Szerokość = BRE;
      }

      public void setHeight (podwójne hei)
      {
         height = hei;
      }
      // Przeciążone + operator sumy dwóch obiektów public static Box Operator Box + (b Box, Box c)
      {
         box = new Box ();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         pole powrócić;
      }

   }

   Klasa Tester
   {
      static void Main (string [] args)
      {
         Box Box1 = new Box (); // zadeklarować box1 typu Box
         Box Box2 = new Box (); // zadeklarować Box2 typu Box
         Box Box3 = new Box (); // zadeklarować Box3 typu Box
         podwójna objętość = 0,0; // // Box1 wyszczególnieniem Box1.setLength (6,0) objętości;
         Box1.setBreadth (7,0);
         Box1.setHeight (5,0);

         // Box2 wyszczególnieniem Box2.setLength (12,0);
         Box2.setBreadth (13,0);
         Box2.setHeight (10,0);

         // Wielkość Box1 objętości = Box1.getVolume ();
         Console.WriteLine ( "objętość Box1: {0}", objętość);

         // Wielkość Box2 objętości = Box2.getVolume ();
         Console.WriteLine ( "objętość Box2: {0}", objętość);

         // Oba obiekty są dodawane Box3 = Box1 + Box2;

         // Wielkość Box3 objętości = Box3.getVolume ();
         Console.WriteLine ( "objętość Box3: {0}", objętość);
         Console.ReadKey ();
      }
   }
}

Gdy powyższy kod jest kompilowany i wykonany, że daje następujące wyniki: 

Objętość box1: 210
Objętość Box2: 1560
Objętość Box3: 5400

Doładować i non-przeciążone operatory

Poniższa tabela opisuje zdolność przeciążenia operatora C #:

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

Przykłady

Na powyższej dyskusji, niech przedłużyć powyższy przykład, bardziej przeciążone operatory: 

using System;

nazw OperatorOvlApplication
{
    Klasa Box
    {
       prywatne długość dwukrotnie; // Długość prywatny pokój wszerz; // szerokość prywatne podwójna wysokość; // wysokość publicznej podwójne getVolume ()
       {
         Długość powrotu * szerokość * wysokość;
       }
      public void setlength (podwójne len)
      {
          długość = len;
      }

      public void setBreadth (podwójne wyl)
      {
          Szerokość = BRE;
      }

      public void setHeight (podwójne hei)
      {
          height = hei;
      }
      // Przeciążone + operator sumy dwóch obiektów public static Box Operator Box + (b Box, Box c)
      {
          box = new Box ();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          pole powrócić;
      }
      
      public static bool operator == (lewa Box, prawa oś Box)
      {
          Stan bool = false;
          if (lhs.length == rhs.length && lhs.height == rhs.height 
             && Lhs.breadth == rhs.breadth)
          {
              status = true;
          }
          stan powrotu;
      }
      public = (lewa, prawa oś Box Box) static bool operator!
      {
          Stan bool = false;
          if (lhs.length! = rhs.length || lhs.height! = rhs.height 
              || Lhs.breadth! = Rhs.breadth)
          {
              status = true;
          }
          stan powrotu;
      }
      public static bool operator <(lewa Box, prawa oś Box)
      {
          Stan bool = false;
          if (lhs.length <rhs.length && lhs.height 
              <Rhs.height && lhs.breadth <rhs.breadth)
          {
              status = true;
          }
          stan powrotu;
      }

      public static bool operator> (lewa Box, prawa oś Box)
      {
          Stan bool = false;
          if (lhs.length> rhs.length && lhs.height 
              > Rhs.height && lhs.breadth> rhs.breadth)
          {
              status = true;
          }
          stan powrotu;
      }

      public static bool operator <= (lewa oś Box, prawa oś Box)
      {
          Stan bool = false;
          if (lhs.length <= rhs.length && lhs.height 
              <= Rhs.height && lhs.breadth <= rhs.breadth)
          {
              status = true;
          }
          stan powrotu;
      }

      public static bool operator> = (lewa oś Box, prawa oś box)
      {
          Stan bool = false;
          if (lhs.length> = rhs.length && lhs.height 
             > = Rhs.height && lhs.breadth> = rhs.breadth)
          {
              status = true;
          }
          stan powrotu;
      }
      public override toString String ()
      {
          powrót String.Format ( "({0} {1}, {2})", długość, szerokość, wysokość);
      }
   
   }
    
   Klasa Tester
   {
      static void Main (string [] args)
      {
        Box Box1 = new Box (); // zadeklarować box1 typu Box
        Box Box2 = new Box (); // zadeklarować Box2 typu Box
        Box Box3 = new Box (); // zadeklarować Box3 typu Box
        Box Box4 = new Box ();
        podwójna objętość = 0,0; // // Box1 wyszczególnieniem Box1.setLength (6,0) objętości;
        Box1.setBreadth (7,0);
        Box1.setHeight (5,0);

        // Box2 wyszczególnieniem Box2.setLength (12,0);
        Box2.setBreadth (13,0);
        Box2.setHeight (10,0);

       // Użyj przeciążony toString () wyświetla dwa pola Console.WriteLine ( "Box1: {0}", Box1.ToString ());
        Console.WriteLine ( "Box2: {0}", Box2.ToString ());
        
        // Wielkość Box1 objętości = Box1.getVolume ();
        Console.WriteLine ( "objętość Box1: {0}", objętość);

        // Wielkość Box2 objętości = Box2.getVolume ();
        Console.WriteLine ( "objętość Box2: {0}", objętość);

        // Oba obiekty są dodawane Box3 = Box1 + Box2;
        Console.WriteLine ( "Box3: {0}", Box3.ToString ());
        // Wielkość Box3 objętości = Box3.getVolume ();
        Console.WriteLine ( "objętość Box3: {0}", objętość);

        // Porównując pola
        if (Box1> Box2)
          Console.WriteLine ( "Ramka 1 większa niż Box2");
        więcej
          Console.WriteLine ( "box1 nie więcej niż Box2");
        if (Box1 <Box2)
          Console.WriteLine ( "Box1 mniej niż Box2");
        więcej
          Console.WriteLine ( "box1 nie mniej niż Box2");
        if (Box1> = Box2)
          Console.WriteLine ( "Ramka 1 większa niż lub równa Box2");
        więcej
          Console.WriteLine ( "Ramka 1 nie większa niż lub równa Box2");
        if (Box1 <= Box2)
          Console.WriteLine ( "Box1 mniej Box2");
        więcej
          Console.WriteLine ( "Box1 nie mniej Box2");
        if (Box1! = Box2)
          Console.WriteLine ( "Box1 nie równa Box2");
        więcej
          Console.WriteLine ( "Box1 równa Box2");
        Box4 = Box3;
        if (Box3 == Box4)
          Console.WriteLine ( "Box3 równa Box4");
        więcej
          Console.WriteLine ( "Box3 nie równa Box4");

        Console.ReadKey ();
      }
    }
}

Gdy powyższy kod jest kompilowany i wykonany, że daje następujące wyniki: 

Ramka 1 (6, 7, 5)
Box2 (12, 13, 10)
Objętość box1: 210
Objętość Box2: 1560
Box3 (18, 20, 15)
Objętość Box3: 5400
Box1 Box2 nie więcej niż
Box1 Box2 mniej niż
Box1 Box2 nie jest większa niż lub równa
Box1 Box2 mniej
Box1 Box2 nie równa
Box3 równa Box4