English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Lezioni di base di C#

Lezioni avanzate di C#

C# Orientato agli oggetti (OOP)

Sovraccaricamento degli operatori in C#

Puoi ridefinire o sovraccaricare gli operatori integrati in C#. Pertanto, i programmatori possono anche utilizzare operatori di tipi personalizzati. L'overloading degli operatori è una funzione con un nome speciale, definita con la chiave di ricerca operator Seguita dal simbolo dell'operatore per definire. Come altre funzioni, l'overloading dell'operatore ha un tipo di ritorno e un elenco di parametri.

Ad esempio, guardate la funzione seguente:

public static Box operator+ (Box b, Box c)
{
　　　Box box = new Box();
　　　box.lunghezza = b.lunghezza + c.lunghezza;
　　　box.larghezza = b.larghezza + c.larghezza;
　　　box.altezza = b.altezza + c.altezza;
　　　return box;
{}

La funzione sopra implements il operatore di somma (+) per la classe Box personalizzata. Aggiunge le proprietà di due oggetti Box e restituisce l'oggetto Box sommato.

Implementazione dell'operatore sovraccaricato

Ecco un programma che dimostra l'implementazione completa:

using System;
namespace OperatorOvlApplication
{
　　　class Box
　　　{
　　　　　　private double length; // lunghezza
　　　　　　private double breadth; // larghezza
　　　　　　private double altezza; // Altezza
　　　　　　public double getVolume()
　　　　　　{
　　　　　　　　　return lunghezza * larghezza * altezza;
　　　　　　{}
　　　　　　public void setLunghezza(double len)
　　　　　　{
　　　　　　　　　lunghezza = len;
　　　　　　{}
　　　　　　public void setLarghezza(double bre)
　　　　　　{
　　　　　　　　　larghezza = bre;
　　　　　　{}
　　　　　　public void setAltezza(double hei)
　　　　　　{
　　　　　　　　　altezza = hei;
　　　　　　{}
　　　　　　// Sostituzione dell'operatore + per sommare due oggetti Box
　　　　　　public static Box operator+ (Box b, Box c)
　　　　　　{
　　　　　　　　　Box box = new Box();
　　　　　　　　　box.lunghezza = b.lunghezza + c.lunghezza;
　　　　　　　　　box.larghezza = b.larghezza + c.larghezza;
　　　　　　　　　box.altezza = b.altezza + c.altezza;
　　　　　　　　　return box;
　　　　　　{}
　　　{}
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　Box Box1 = new Box(); // Dichiarazione Box1, tipo Box
　　　　　　　　　Box Box2 = new Box(); // Dichiarazione Box2, tipo Box
　　　　　　　　　Box Box3 = new Box(); // Dichiarazione Box3, tipo Box
　　　　　　　　　double volume = 0.0; // volume
　　　　　　　　　// Dettagli di Scatola1
　　　　　　　　　Scatola1.setLunghezza(6.0);
　　　　　　　　　Scatola1.setLarghezza(7.0);
　　　　　　　　　Scatola1.setAltezza(5.0);
　　　　　　　　　// Dettagli di Scatola2
　　　　　　　　　Scatola2.setLunghezza(12.0);
　　　　　　　　　Scatola2.setLarghezza(13.0);
　　　　　　　　　Scatola2.setAltezza(10.0);
　　　　　　　　　//Il volume di Box1
　　　　　　　　　volume = Box1.getVolume();
　　　　　　　　　Console.WriteLine("Il volume di Box1: {0}", volume);
　　　　　　　　　//Il volume di Box2
　　　　　　　　　volume = Box2.getVolume();
　　　　　　　　　Console.WriteLine("Il volume di Box2: {0}", volume);
　　　　　　　　　//Aggiungendo due oggetti
　　　　　　　　　Box3 = Box1 + Box2;
　　　　　　　　　//Il volume di Box3
　　　　　　　　　volume = Box3.getVolume();
　　　　　　　　　Console.WriteLine("Il volume di Box3: {0}", volume);
　　　　　　　　　Console.ReadKey();
　　　　　　{}
　　　{}
{}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

Volume di Box1: 210
Volume di Box2: 1560
Volume di Box3: 5400

Operatori sovraccaricabili e non sovraccaricabili

La tabella seguente descrive le capacità di sovraccaricamento degli operatori in C#:

OperatoreDescrizione
+, -, !, ~, ++, --Questi operatori unari hanno un solo operando e possono essere sovraccaricati.
+, -, *, /, %Questi operatori binari hanno due operandi e possono essere sovraccaricati.
==, !=, <, >, <=, >=Questi operatori di confronto possono essere sovraccaricati.
&&, ||Questi operatori logici condizionali non possono essere sovraccaricati direttamente.
+=, -=, *=, /=, %=Questi operatori di assegnazione non possono essere sovraccaricati.
=, ., ?:, ->, new, is, sizeof, typeofQuesti operatori non possono essere sovraccaricati.

Esempio online

In relazione alla discussione sopra, espandiamo l'esempio sopra per sovraccaricare più operatori:

using System;
namespace OperatorOvlApplication
{
　　　　class Box
　　　　{
　　　　　　　private double length; // lunghezza
　　　　　　　private double breadth; // larghezza
　　　　　　　private double altezza; // Altezza
　　　　　　
　　　　　　　public double getVolume()
　　　　　　　{
　　　　　　　　　return lunghezza * larghezza * altezza;
　　　　　　　{}
　　　　　　public void setLunghezza(double len)
　　　　　　{
　　　　　　　　　　lunghezza = len;
　　　　　　{}
　　　　　　public void setLarghezza(double bre)
　　　　　　{
　　　　　　　　　　larghezza = bre;
　　　　　　{}
　　　　　　public void setAltezza(double hei)
　　　　　　{
　　　　　　　　　　altezza = hei;
　　　　　　{}
　　　　　　// Sostituzione dell'operatore + per sommare due oggetti Box
　　　　　　public static Box operator+ (Box b, Box c)
　　　　　　{
　　　　　　　　　　Box box = new Box();
　　　　　　　　　　box.lunghezza = b.lunghezza + c.lunghezza;
　　　　　　　　　　box.larghezza = b.larghezza + c.larghezza;
　　　　　　　　　　box.altezza = b.altezza + c.altezza;
　　　　　　　　　　return box;
　　　　　　{}
　　　　　　
　　　　　　public static bool operator == (Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.lunghezza == rhs.lunghezza && lhs.altezza == rhs.altezza　
　　　　　　　　　　　　　&& lhs.larghezza == rhs.larghezza)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　{}
　　　　　　　　　　return status;
　　　　　　{}
　　　　　　public static bool operator != (Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.lunghezza != rhs.lunghezza || lhs.altezza != rhs.altezza　
　　　　　　　　　　　　　　|| lhs.larghezza != rhs.larghezza)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　{}
　　　　　　　　　　return status;
　　　　　　{}
　　　　　　public static bool operator < (Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.lunghezza < rhs.lunghezza && lhs.altezza　
　　　　　　　　　　　　　　< rhs.altezza && lhs.larghezza < rhs.larghezza)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　{}
　　　　　　　　　　return status;
　　　　　　{}
　　　　　　public static bool operator > (Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.lunghezza > rhs.lunghezza && lhs.altezza　
　　　　　　　　　　　　　　> rhs.altezza && lhs.larghezza > rhs.larghezza)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　{}
　　　　　　　　　　return status;
　　　　　　{}
　　　　　　public static bool operator <=(Scatola lhs, Scatola rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.lunghezza <= rhs.lunghezza && lhs.altezza　
　　　　　　　　　　　　　　<= rhs.altezza && lhs.larghezza <= rhs.larghezza)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　{}
　　　　　　　　　　return status;
　　　　　　{}
　　　　　　public static bool operator >=(Scatola lhs, Scatola rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.lunghezza >= rhs.lunghezza && lhs.altezza　
　　　　　　　　　　　　　>= rhs.altezza && lhs.larghezza >= rhs.larghezza)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　{}
　　　　　　　　　　return status;
　　　　　　{}
　　　　　　public override string ToString()
　　　　　　{
　　　　　　　　　　return String.Format("({0}, {1}, {2})", length, larghezza, altezza);
　　　　　　{}
　　　
　　　{}
　　　　
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　Scatola Box1 = new Scatola(); // Dichiarazione di Box1, tipo Scatola
　　　　　　　　Scatola Box2 = new Scatola(); // Dichiarazione di Box2, tipo Scatola
　　　　　　　　Scatola Box3 = new Scatola(); // Dichiarazione di Box3, tipo Scatola
　　　　　　　　Scatola Box4 = new Scatola();
　　　　　　　　double volume = 0.0; // Volume
　　　　　　　　// Dettagli di Scatola1
　　　　　　　　Scatola1.setLunghezza(6.0);
　　　　　　　　Scatola1.setLarghezza(7.0);
　　　　　　　　Scatola1.setAltezza(5.0);
　　　　　　　　// Dettagli di Scatola2
　　　　　　　　Scatola2.setLunghezza(12.0);
　　　　　　　　Scatola2.setLarghezza(13.0);
　　　　　　　　Scatola2.setAltezza(10.0);
　　　　　　　// Utilizzo di ToString() sovraccaricato per visualizzare due scatole
　　　　　　　　Console.WriteLine("Scatola1: {0}", Scatola1.ToString());
　　　　　　　　Console.WriteLine("Box2: {0}", Box2.ToString());
　　　　　　　　
　　　　　　　　//Il volume di Box1
　　　　　　　　volume = Box1.getVolume();
　　　　　　　　Console.WriteLine("Il volume di Box1: {0}", volume);
　　　　　　　　//Il volume di Box2
　　　　　　　　volume = Box2.getVolume();
　　　　　　　　Console.WriteLine("Il volume di Box2: {0}", volume);
　　　　　　　　//Aggiungendo due oggetti
　　　　　　　　Box3 = Box1 + Box2;
　　　　　　　　Console.WriteLine("Box3: {0}", Box3.ToString());
　　　　　　　　//Il volume di Box3
　　　　　　　　volume = Box3.getVolume();
　　　　　　　　Console.WriteLine("Il volume di Box3: {0}", volume);
　　　　　　　　//comparing the boxes
　　　　　　　　if (Box1 > Box2)
　　　　　　　　　　Console.WriteLine("Box1 è maggiore di Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1 non è maggiore di Box2");
　　　　　　　　if (Box1 < Box2)
　　　　　　　　　　Console.WriteLine("Box1 è minore di Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1 non è minore di Box2");
　　　　　　　　if (Box1 >= Box2)
　　　　　　　　　　Console.WriteLine("Box1 è maggiore o uguale a Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1 non è maggiore o uguale a Box2");
　　　　　　　　if (Box1 <= Box2)
　　　　　　　　　　Console.WriteLine("Box1 è minore o uguale a Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1 non è minore o uguale a Box2");
　　　　　　　　if (Box1 != Box2)
　　　　　　　　　　Console.WriteLine("Box1 non è uguale a Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1 è uguale a Box2");
　　　　　　　　Box4 = Box3;
　　　　　　　　if (Box3 == Box4)
　　　　　　　　　　Console.WriteLine("Box3 è uguale a Box4");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box3 non è uguale a Box4");
　　　　　　　　Console.ReadKey();
　　　　　　{}
　　　　{}
{}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

Box1: (6, 7, 5)
Box2: (12, 13, 10)
Volume di Box1: 210
Volume di Box2: 1560
Box3: (18, 20, 15)
Volume di Box3: 5400
Box1 non è maggiore di Box2
Box1 è minore di Box2
Box1 non è maggiore o uguale di Box2
Box1 è uguale o minore di Box2
Box1 non è uguale a Box2
Box3 è uguale a Box4
Namespace di C#Polimorfismo di C#