Latest web development tutorials

# Surcharge d'opérateur C

Vous pouvez redéfinir ou remplacer le C # opérateur intégré. Par conséquent, les programmeurs peuvent utiliser les opérateurs de type défini par l'utilisateur. les opérateurs surchargés ont un nom de fonction spéciale, suivie par la définition du symbole de l' opérateurde l' opérateurde mot - clé. Et d'autres fonctions, les opérateurs surchargés ont un type de retour et la liste des paramètres.

Par exemple, considérons la fonction suivante: 

Box opérateur public static + (encadré b, c Box)
{
   boîte de Box = new Box ();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   boîte de retour;
}

La fonction ci-dessus est la classe boîte définie par l'utilisateur met en oeuvre l'opérateur d'addition (+). Il est la propriété de deux objets Box sont ajoutés, et le retour des objets de boîte ajouté.

Opérateur surcharge pour atteindre

Le programme suivant illustre la mise en œuvre complète: 

using System;

namespace OperatorOvlApplication
{
   classe Box
   {
      longueur double privée; // double longueur étendue privée; // largeur double hauteur privée; // hauteur publique à double getVolume ()
      {
         longueur de retour * largeur * hauteur;
      }
      setLength public void (double len)
      {
         longueur = len;
      }

      setBreadth public void (double rep)
      {
         largeur = rep;
      }

      setHeight public void (double hei)
      {
         height = hei;
      }
      // Surchargé opérateur + à la somme des deux objets Box public static Box opérateur + (encadré b, c Box)
      {
         boîte de Box = new Box ();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         boîte de retour;
      }

   }

   Testeur de classe
   {
      static void Main (string [] args)
      {
         Box Box1 = new Box (); // déclarer Box1, tapez Box
         Box Box2 = new Box (); // déclarer Box2, tapez Box
         Box Box3 = new Box (); // déclarer Box3, tapez Box
         volume double = 0,0; // // Box1 volume de détails Box1.setLength (6.0);
         Box1.setBreadth (7.0);
         Box1.setHeight (5,0);

         // Box2 détaillant Box2.setLength (12,0);
         Box2.setBreadth (13.0);
         Box2.setHeight (10,0);

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

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

         // Les deux objets sont ajoutés Box3 = Box1 + Box2;

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

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants: 

le volume Box1: 210
le volume Box2: 1560
le volume Box3: 5400

opérateurs et rechargeables non-surchargé

Le tableau suivant décrit la capacité de la surcharge de l'opérateur C #:

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

Exemples

Pour la discussion ci-dessus, nous allons étendre l'exemple ci-dessus, les opérateurs plus surchargés: 

using System;

namespace OperatorOvlApplication
{
    classe Box
    {
       longueur double privée; // double longueur étendue privée; // largeur double hauteur privée; // hauteur publique à double getVolume ()
       {
         longueur de retour * largeur * hauteur;
       }
      setLength public void (double len)
      {
          longueur = len;
      }

      setBreadth public void (double rep)
      {
          largeur = rep;
      }

      setHeight public void (double hei)
      {
          height = hei;
      }
      // Surchargé opérateur + à la somme des deux objets Box public static Box opérateur + (encadré b, c Box)
      {
          boîte de Box = new Box ();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          boîte de retour;
      }
      
      public static == opérateur booléen (Box lhs, Box rhs)
      {
          état bool = false;
          if (lhs.length == rhs.length && lhs.height == rhs.height 
             && Lhs.breadth == rhs.breadth)
          {
              status = true;
          }
          retourner le statut;
      }
      bool operator public static! = (lhs Box, Box rhs)
      {
          état bool = false;
          if (lhs.length! = rhs.length || lhs.height! = rhs.height 
              || Lhs.breadth! = Rhs.breadth)
          {
              status = true;
          }
          retourner le statut;
      }
      bool operator public static <(Box lhs, Box rhs)
      {
          état bool = false;
          if (lhs.length <rhs.length && lhs.height 
              <Rhs.height && lhs.breadth <rhs.breadth)
          {
              status = true;
          }
          retourner le statut;
      }

      bool operator public static> (Box lhs, Box rhs)
      {
          état bool = false;
          if (lhs.length> rhs.length && lhs.height 
              > Rhs.height && lhs.breadth> rhs.breadth)
          {
              status = true;
          }
          retourner le statut;
      }

      bool operator public static <= (Box lhs, Box rhs)
      {
          état bool = false;
          if (lhs.length <= && rhs.length lhs.height 
              <= Lhs.breadth Rhs.height && <= rhs.breadth)
          {
              status = true;
          }
          retourner le statut;
      }

      opérateur booléen public static> = (lhs Box, Box rhs)
      {
          état bool = false;
          if (lhs.length> = && rhs.length lhs.height 
             > = Rhs.height lhs.breadth &&> = rhs.breadth)
          {
              status = true;
          }
          retourner le statut;
      }
      public override string ToString ()
      {
          retour String.Format ( "({0}, {1}, {2})", longueur, largeur, hauteur);
      }
   
   }
    
   Testeur de classe
   {
      static void Main (string [] args)
      {
        Box Box1 = new Box (); // déclarer Box1, tapez Box
        Box Box2 = new Box (); // déclarer Box2, tapez Box
        Box Box3 = new Box (); // déclarer Box3, tapez Box
        Box box4 = new Box ();
        volume double = 0,0; // // Box1 volume de détails Box1.setLength (6.0);
        Box1.setBreadth (7.0);
        Box1.setHeight (5,0);

        // Box2 détaillant Box2.setLength (12,0);
        Box2.setBreadth (13.0);
        Box2.setHeight (10,0);

       // Utilisez le ToString surchargé () affiche deux boîtes Console.WriteLine ( "Box1: {0}", Box1.ToString ());
        Console.WriteLine ( "Box2: {0}", Box2.ToString ());
        
        // Volume de Box1 de volume = Box1.getVolume ();
        Console.WriteLine ( «volume Box1: {0}", volume);

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

        // Les deux objets sont ajoutés Box3 = Box1 + Box2;
        Console.WriteLine ( "Box3: {0}", Box3.ToString ());
        // Volume de Box3 de volume = Box3.getVolume ();
        Console.WriteLine ( «volume Box3: {0}", volume);

        // En comparant les boîtes
        if (Box1> Box2)
          Console.WriteLine ( "Box1 supérieure à Box2");
        autre
          Console.WriteLine ( "box1 pas plus de Box2");
        if (Box1 <Box2)
          Console.WriteLine ( "Box1 moins de Box2");
        autre
          Console.WriteLine ( "box1 pas moins de Box2");
        if (Box1> = Box2)
          Console.WriteLine ( "Box1 supérieure ou égale Box2");
        autre
          Console.WriteLine ( "box1 pas supérieur ou égal Box2");
        if (Box1 <= Box2)
          Console.WriteLine ( "Box1 moins Box2");
        autre
          Console.WriteLine ( "Box1 moins Box2");
        if (Box1! = Box2)
          Console.WriteLine ( "Box1 pas égal Box2");
        autre
          Console.WriteLine ( "Box1 égale Box2");
        Box4 = Box3;
        if (Box3 == box4)
          Console.WriteLine ( "Box3 égale box4");
        autre
          Console.WriteLine ( "Box3 pas égal box4");

        Console.ReadKey ();
      }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants: 

Boite1: (6, 7, 5)
Box2: (12, 13, 10)
le volume Box1: 210
le volume Box2: 1560
Boite3: (18, 20, 15)
le volume Box3: 5400
Box1 Box2 pas plus de
Box1 Box2 moins
Boite1 Box2 ne soit pas supérieur ou égal
Box1 Box2 moins
Box1 Box2 pas égal
Box3 égale box4