C# Operatorüberladung

Sie können in C# integrierte Operatoren neu definieren oder überladen. Daher können Programmierer Operatoren auch mit benutzerdefinierten Typen verwenden. Überladene Operatoren sind Funktionen mit speziellen Namen, die durch das Schlüsselwortoperatorgefolgt vom Symbol des Operators definiert werden. Wie andere Funktionen haben überladene Operatoren einen Rückgabetyp und eine Parameterliste.

Betrachten Sie beispielsweise die folgende Funktion:

public static Box operator+ (Box b, Box c)
{
   Box box = new Box();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   return box;
}

Die obige Funktion implementiert den Additionsoperator (+) für die benutzerdefinierte Klasse Box. Sie addiert die Eigenschaften zweier Box-Objekte und gibt das resultierende Box-Objekt zurück.

Implementierung der Operatorüberladung

Das folgende Programm demonstriert die vollständige Implementierung:

Beispiel

using System;

namespace OperatorOvlApplication
{
   class Box
   {
      private double length;      // Länge
      private double breadth;     // Breite
      private double height;      // Höhe

      public double getVolume()
      {
         return length * breadth * height;
      }
      public void setLength( double len )
      {
         length = len;
      }

      public void setBreadth( double bre )
      {
         breadth = bre;
      }

      public void setHeight( double hei )
      {
         height = hei;
      }
      // Überladen des +-Operators, um zwei Box-Objekte zu addieren
      public static Box operator+ (Box b, Box c)
      {
         Box box = new Box();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         return box;
      }

   }

   class Tester
   {
      static void Main(string[] args)
      {
         Box Box1 = new Box();         // Deklariere Box1 vom Typ Box
         Box Box2 = new Box();         // Deklariere Box2 vom Typ Box
         Box Box3 = new Box();         // Box3 vom Typ Box deklarieren
         double volume = 0.0;          // Volumen

         // Box1-Details
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);

         // Box2-Details
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);

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

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

         // zwei Objekte addieren
         Box3 = Box1 + Box2;

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

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

Box1 的体积： 210
Box2 的体积： 1560
Box3 的体积： 5400

Operatoren, die überladen werden können und nicht überladen werden können

Die folgende Tabelle beschreibt die Möglichkeiten der Operatorüberladung in C#:

OperatorenBeschreibung
+, -, !, ~, ++, --Diese unären Operatoren nehmen einen einzelnen Operanden und können überladen werden.
+, -, *, /, %Diese binären Operatoren nehmen zwei Operanden und können überladen werden.
==, !=, <, >, <=, >=Diese Vergleichsoperatoren können überladen werden.
&&, ||Diese bedingten logischen Operatoren können nicht direkt überladen werden.
+=, -=, *=, /=, %=Diese Zuweisungsoperatoren können nicht überladen werden.
=, ., ?:, ->, new, is, sizeof, typeofDiese Operatoren können nicht überladen werden.

Beispiel

Basierend auf der obigen Diskussion erweitern wir das obige Beispiel, um weitere Operatoren zu überladen:

Beispiel

using System;

namespace OperatorOvlApplication
{
    class Box
    {
       private double length;      // Länge
       private double breadth;     // Breite
       private double height;      // Höhe
     
       public double getVolume()
       {
         return length * breadth * height;
       }
      public void setLength( double len )
      {
          length = len;
      }

      public void setBreadth( double bre )
      {
          breadth = bre;
      }

      public void setHeight( double hei )
      {
          height = hei;
      }
      // Überladen des +-Operators, um zwei Box-Objekte zu addieren
      public static Box operator+ (Box b, Box c)
      {
          Box box = new Box();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          return 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;
          }
          return status;
      }
      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;
          }
          return status;
      }
      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;
          }
          return status;
      }

      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;
          }
          return status;
      }

      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;
          }
          return status;
      }

      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;
          }
          return status;
      }
      public override string ToString()
      {
          return String.Format("({0}, {1}, {2})", length, breadth, height);
      }
   
   }
   
   class Tester
   {
      static void Main(string[] args)
      {
        Box Box1 = new Box();          // Deklariere Box1 vom Typ Box
        Box Box2 = new Box();          // Deklariere Box2 vom Typ Box
        Box Box3 = new Box();          // Box3 vom Typ Box deklarieren
        Box Box4 = new Box();
        double volume = 0.0;   // Volumen

        // Box1-Details
        Box1.setLength(6.0);
        Box1.setBreadth(7.0);
        Box1.setHeight(5.0);

        // Box2-Details
        Box2.setLength(12.0);
        Box2.setBreadth(13.0);
        Box2.setHeight(10.0);

       // Verwende das überladene ToString(), um die beiden Boxen anzuzeigen
        Console.WriteLine("Box1： {0}", Box1.ToString());
        Console.WriteLine("Box2： {0}", Box2.ToString());
       
        // Volumen von Box1
        volume = Box1.getVolume();
        Console.WriteLine("Volumen von Box1: {0}", volume);

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

        // zwei Objekte addieren
        Box3 = Box1 + Box2;
        Console.WriteLine("Box3： {0}", Box3.ToString());
        // Volumen von Box3
        volume = Box3.getVolume();
        Console.WriteLine("Volumen von Box3: {0}", volume);

        // Vergleich der Boxen
        if (Box1 > Box2)
          Console.WriteLine(Box1 ist größer als Box2);
        else
          Console.WriteLine("Box1 ist nicht größer als Box2");
        if (Box1 < Box2)
          Console.WriteLine(Box1 ist kleiner als Box2);
        else
          Console.WriteLine("Box1 ist nicht kleiner als Box2");
        if (Box1 >= Box2)
          Console.WriteLine("Box1 ist größer oder gleich Box2");
        else
          Console.WriteLine(Box1 ist nicht größer oder gleich Box2);
        if (Box1 <= Box2)
          Console.WriteLine("Box1 ist kleiner oder gleich Box2");
        else
          Console.WriteLine(Box1 ist nicht kleiner oder gleich Box2);
        if (Box1 != Box2)
          Console.WriteLine("Box1 ist nicht gleich Box2");
        else
          Console.WriteLine(Box1 ist gleich Box2);
        Box4 = Box3;
        if (Box3 == Box4)
          Console.WriteLine(Box3 ist gleich Box4);
        else
          Console.WriteLine("Box3 ist nicht gleich Box4");

        Console.ReadKey();
      }
    }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:

Box1： (6, 7, 5)
Box2： (12, 13, 10)
Box1 的体积： 210
Box2 的体积： 1560
Box3： (18, 20, 15)
Box3 的体积： 5400
Box1 不大于 Box2
Box1 小于 Box2
Box1 不大于等于 Box2
Box1 小于等于 Box2
Box1 不等于 Box2
Box3 等于 Box4
Weitere Erweiterungen