Latest web development tutorials

C # Betreiber Überlastung

Sie können die eingebaute in C # Bediener neu zu definieren oder außer Kraft setzen. Daher können Programmierer die benutzerdefinierten Operatoren Typ verwenden. Überladene Operatoren werden mit einem speziellen Funktionsnamen, gefolgt von dem SchlüsselwortOperator Operator Symbol Definition.Und andere Funktionen überladene Operatoren haben einen Rückgabetyp und Parameterliste.

Betrachten wir zum Beispiel die folgende Funktion: 

public static Box Operator + (Box b, Box c)
{
   Box box = neue Box ();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   Rückkehr-Box;
}

Die obige Funktion ist benutzerdefinierten Klasse Box implementiert den Additionsoperator (+). Es ist die Eigenschaft von zwei Box-Objekte hinzugefügt werden, und die Rück Box Objekte hinzugefügt.

Betreiber Überlastung zu erreichen

Das folgende Programm zeigt die vollständige Umsetzung: 

using System;

Namespace OperatorOvlApplication
{
   Klasse Box
   {
      private Doppel Länge; // Länge private Doppel Breite; // Breite private Doppel Höhe; // Höhe public double getVolume ()
      {
         Rückkehr Länge * Breite * Höhe;
      }
      public void setlength (double len)
      {
         length = len;
      }

      public void setBreadth (Doppel bre)
      {
         Breite = bre;
      }

      public void setHeight (Doppel hei)
      {
         height = hei;
      }
      // Überladene + Operator auf die Summe der beiden Box-Objekte public static Box Operator + (Box b, Box c)
      {
         Box box = neue Box ();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         Rückkehr-Box;
      }

   }

   Klasse Tester
   {
      static void Main (string [] args)
      {
         Box Box1 = new Box (); // erklären Box1, Typ Box
         Box Box2 = new Box (); // erklären Box2, Typ Box
         Box Box3 = new Box (); // erklären Box3, Typ Box
         Doppel Volumen = 0,0; // // Box1 Volumen Detaillierung Box1.setLength (6.0);
         Box1.setBreadth (7.0);
         Box1.setHeight (5,0);

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

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

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

         // Die beiden Objekte hinzugefügt Box3 = Box1 + Box2;

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

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Box1 Volumen: 210
Box2 Volumen: 1560
Box3 Volumen: 5400

Wiederbeladbare und nicht-überladene Operatoren

Die folgende Tabelle beschreibt die Fähigkeit des C # Betreiber Überlastung:

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

Beispiele

Für die obige Diskussion, lassen Sie uns das Beispiel oben erweitern, mehr überladene Operatoren: 

using System;

Namespace OperatorOvlApplication
{
    Klasse Box
    {
       private Doppel Länge; // Länge private Doppel Breite; // Breite private Doppel Höhe; // Höhe public double getVolume ()
       {
         Rückkehr Länge * Breite * Höhe;
       }
      public void setlength (double len)
      {
          length = len;
      }

      public void setBreadth (Doppel bre)
      {
          Breite = bre;
      }

      public void setHeight (Doppel hei)
      {
          height = hei;
      }
      // Überladene + Operator auf die Summe der beiden Box-Objekte public static Box Operator + (Box b, Box c)
      {
          Box box = neue Box ();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          Rückkehr-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;
          }
          Zustand zurückzukehren;
      }
      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;
          }
          Zustand zurückzukehren;
      }
      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;
          }
          Zustand zurückzukehren;
      }

      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;
          }
          Zustand zurückzukehren;
      }

      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;
          }
          Zustand zurückzukehren;
      }

      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;
          }
          Zustand zurückzukehren;
      }
      public override string ToString ()
      {
          Rückkehr String.Format ( "({0}, {1}, {2})", Länge, Breite, Höhe);
      }
   
   }
    
   Klasse Tester
   {
      static void Main (string [] args)
      {
        Box Box1 = new Box (); // erklären Box1, Typ Box
        Box Box2 = new Box (); // erklären Box2, Typ Box
        Box Box3 = new Box (); // erklären Box3, Typ Box
        Box Box4 = new Box ();
        Doppel Volumen = 0,0; // // Box1 Volumen Detaillierung Box1.setLength (6.0);
        Box1.setBreadth (7.0);
        Box1.setHeight (5,0);

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

       // Verwenden Sie die überladene ToString () zwei Boxen Console.WriteLine ( "Box1: {0}", Box1.ToString ());
        Console.WriteLine ( "Box2: {0}", Box2.ToString ());
        
        // Box1 Volumen = Volumen Box1.getVolume ();
        Console.WriteLine ( "Box1 Volumen: {0}", Volumen);

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

        // Die beiden Objekte hinzugefügt Box3 = Box1 + Box2;
        Console.WriteLine ( "Box3: {0}", Box3.ToString ());
        // Box3 Volumen = Volumen Box3.getVolume ();
        Console.WriteLine ( "Box3 Volumen: {0}", Volumen);

        // Vergleicht man die Boxen
        if (Box1> Box2)
          Console.WriteLine ( "Box1 größer als Box2");
        sonst
          Console.WriteLine ( "box1 nicht mehr als Box2");
        if (Box1 <Box2)
          Console.WriteLine ( "Box1 weniger als Box2");
        sonst
          Console.WriteLine ( "box1 nicht weniger als Box2");
        if (Box1> = Box2)
          Console.WriteLine ( "Box1 größer oder gleich Box2");
        sonst
          Console.WriteLine ( "BOX1 nicht größer oder gleich Box2");
        if (Box1 <= Box2)
          Console.WriteLine ( "Box1 weniger Box2");
        sonst
          Console.WriteLine ( "Box1 nicht weniger Box2");
        if (Box1! = Box2)
          Console.WriteLine ( "Box1 nicht gleich Box2");
        sonst
          Console.WriteLine ( "Box1 gleich Box2");
        Box4 = Box3;
        if (Box3 == Box4)
          Console.WriteLine ( "Box3 gleich Box4");
        sonst
          Console.WriteLine ( "Box3 nicht gleich Box4");

        Console.ReadKey ();
      }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse: 

Box 1: (6, 7, 5)
Box2: (12, 13, 10)
Box1 Volumen: 210
Box2 Volumen: 1560
BOX3: (18, 20, 15)
Box3 Volumen: 5400
Box1 Box2 nicht mehr als
Box1 Box2 weniger als
Box1 Box2 nicht größer als oder gleich
Box1 Box2 weniger
Box1 Box2 nicht gleich
Box3 gleich Box4