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

Tutorial básico de C#

Tutorial avanzado de C#

C# Orientado a Objetos (OOP)

Sobrecarga de operadores en C#

Puede redefine o sobrecargar operadores integrados en C#. Por lo tanto, los programadores también pueden usar operadores de tipos personalizados. La sobrecarga de operadores es una función con un nombre especial, que se realiza mediante la palabra clave operator Definidos por el símbolo de operador que sigue. Al igual que otras funciones, la sobrecarga de operadores tiene un tipo de retorno y una lista de parámetros.

Por ejemplo, vea la función siguiente:

public static Box operator+　(Box b, Box c)
{
　　　Box box = new Box();
　　　box.largo = b.largo　+　c.largo;
　　　box.ancho = b.ancho　+　c.ancho;
　　　box.altura = b.altura　+　c.altura;
　　　return box;
}

La función anterior implementa el operador de suma para la clase Box personalizada:+）。Agrega las propiedades de dos objetos Box y devuelve el objeto Box resultante.

Implementación de sobrecarga de operadores

El siguiente programa muestra la implementación completa:

using System;
namespace OperatorOvlApplication
{
　　　class Box
　　　{
　　　　　　private double largo;　　　　　　//　largo
　　　　　　private double ancho;　　　　　//　ancho
　　　　　　private double altura;　　　　　　//　altura
　　　　　　public double getVolume()
　　　　　　{
　　　　　　　　　return largo　*　ancho　*　altura
　　　　　　}
　　　　　　public void setLargo(double len)
　　　　　　{
　　　　　　　　　largo = len;
　　　　　　}
　　　　　　public void setAncho(double bre)
　　　　　　{
　　　　　　　　　ancho = bre;
　　　　　　}
　　　　　　public void setAltura(double hei)
　　　　　　{
　　　　　　　　　altura = hei;
　　　　　　}
　　　　　　//　sobrecarga　+　operadores para sumar dos objetos Box
　　　　　　public static Box operator+　(Box b, Box c)
　　　　　　{
　　　　　　　　　Box box = new Box();
　　　　　　　　　box.largo = b.largo　+　c.largo;
　　　　　　　　　box.ancho = b.ancho　+　c.ancho;
　　　　　　　　　box.altura = b.altura　+　c.altura;
　　　　　　　　　return box;
　　　　　　}
　　　}
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　Box Box1　= new Box();　　　　　　　　　//　declarar Box1de tipo Box
　　　　　　　　　Box Box2　= new Box();　　　　　　　　　//　declarar Box2de tipo Box
　　　　　　　　　Box Box3　= new Box();　　　　　　　　　//　declarar Box3de tipo Box
　　　　　　　　　double volumen = 0.0;　　　　　　　　　　//　volumen
　　　　　　　　　//　Box1　detallar
　　　　　　　　　Box1.setLongitud(6.0);
　　　　　　　　　Box1.setAnchura(7.0);
　　　　　　　　　Box1.setHeight(5.0);
　　　　　　　　　//　Box2　detallar
　　　　　　　　　Box2.setLongitud(12.0);
　　　　　　　　　Box2.setAnchura(13.0);
　　　　　　　　　Box2.setHeight(10.0);
　　　　　　　　　//　Box1　el volumen
　　　　　　　　　volumen = Box1.getVolume();
　　　　　　　　　Console.WriteLine("Box1　el volumen: {0}
　　　　　　　　　//　Box2　el volumen
　　　　　　　　　volumen = Box2.getVolume();
　　　　　　　　　Console.WriteLine("Box2　el volumen: {0}
　　　　　　　　　//　sumar dos objetos
　　　　　　　　　Box3　Igual a Box1　+　Box2;
　　　　　　　　　//　Box3　el volumen
　　　　　　　　　volumen = Box3.getVolume();
　　　　　　　　　Console.WriteLine("Box3　el volumen: {0}
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Cuando el código superior se compila y ejecuta, producirá el siguiente resultado:

Box1　El volumen:　210
Box2　El volumen:　1560
Box3　El volumen:　5400

Operadores sobrecargables e in sobrecargables

La siguiente tabla describe las capacidades de sobrecarga de operadores en C#:

OperadorDescripción
+, -, !, ~, ++, --Estos operadores unarios tienen un solo operando y pueden ser sobrecargados.
+, -, *, /, %Estos operadores binarios tienen dos operandos y pueden ser sobrecargados.
==, !=, <, >, <=, >=Estos operadores de comparación pueden ser sobrecargados.
&&, ||Estos operadores lógicos de condiciones no pueden ser sobrecargados directamente.
+=, -=, *=, /=, %=Estos operadores de asignación no pueden ser sobrecargados.
>=, ., ?:, ->, new, is, sizeof, typeofEstos operadores no pueden ser sobrecargados.

ejemplo en línea

En respuesta a lo discutido anteriormente, extendamos el ejemplo anterior, sobrecargando más operadores:

using System;
namespace OperatorOvlApplication
{
　　　　class Box
　　　　{
　　　　　　　private double largo;　　　　　　//　largo
　　　　　　　private double ancho;　　　　　//　ancho
　　　　　　　private double altura;　　　　　　//　altura
　　　　　　
　　　　　　　public double getVolume()
　　　　　　　{
　　　　　　　　　return largo　*　ancho　*　altura
　　　　　　　}
　　　　　　public void setLargo(double len)
　　　　　　{
　　　　　　　　　　largo = len;
　　　　　　}
　　　　　　public void setAncho(double bre)
　　　　　　{
　　　　　　　　　　ancho = bre;
　　　　　　}
　　　　　　public void setAltura(double hei)
　　　　　　{
　　　　　　　　　　altura = hei;
　　　　　　}
　　　　　　//　sobrecarga　+　operadores para sumar dos objetos Box
　　　　　　public static Box operator+　(Box b, Box c)
　　　　　　{
　　　　　　　　　　Box box = new Box();
　　　　　　　　　　box.largo = b.largo　+　c.largo;
　　　　　　　　　　box.ancho = b.ancho　+　c.ancho;
　　　　　　　　　　box.altura = b.altura　+　c.altura;
　　　　　　　　　　return box;
　　　　　　}
　　　　　　
　　　　　　public static bool operator ==(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool estado = false;
　　　　　　　　　　if (lhs.largo == rhs.largo && lhs.altura == rhs.altura　
　　　　　　　　　　　　　&& lhs.ancho == rhs.ancho)
　　　　　　　　　　{
　　　　　　　　　　　　　　estado = true;
　　　　　　　　　　}
　　　　　　　　　　return estado;
　　　　　　}
　　　　　　public static bool operator !=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool estado = false;
　　　　　　　　　　if (lhs.largo != rhs.largo || lhs.altura != rhs.altura　
　　　　　　　　　　　　　　|| lhs.ancho != rhs.ancho)
　　　　　　　　　　{
　　　　　　　　　　　　　　estado = true;
　　　　　　　　　　}
　　　　　　　　　　return estado;
　　　　　　}
　　　　　　public static bool operator <(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool estado = false;
　　　　　　　　　　if (lhs.longitud < rhs.longitud && lhs.altura　
　　　　　　　　　　　　　　< rhs.altura && lhs.anchura < rhs.anchura)
　　　　　　　　　　{
　　　　　　　　　　　　　　estado = true;
　　　　　　　　　　}
　　　　　　　　　　return estado;
　　　　　　}
　　　　　　public static bool operador > (Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool estado = false;
　　　　　　　　　　if (lhs.longitud > rhs.longitud && lhs.altura　
　　　　　　　　　　　　　　> rhs.altura && lhs.anchura > rhs.anchura)
　　　　　　　　　　{
　　　　　　　　　　　　　　estado = true;
　　　　　　　　　　}
　　　　　　　　　　return estado;
　　　　　　}
　　　　　　public static bool operador <= (Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool estado = false;
　　　　　　　　　　if (lhs.longitud <= rhs.longitud && lhs.altura　
　　　　　　　　　　　　　　<= rhs.altura && lhs.anchura <= rhs.anchura)
　　　　　　　　　　{
　　　　　　　　　　　　　　estado = true;
　　　　　　　　　　}
　　　　　　　　　　return estado;
　　　　　　}
　　　　　　public static bool operador >= (Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool estado = false;
　　　　　　　　　　if (lhs.longitud >= rhs.longitud && lhs.altura　
　　　　　　　　　　　　　>= rhs.altura && lhs.anchura >= rhs.anchura)
　　　　　　　　　　{
　　　　　　　　　　　　　　estado = true;
　　　　　　　　　　}
　　　　　　　　　　return estado;
　　　　　　}
　　　　　　public override string ToString()
　　　　　　{
　　　　　　　　　　return String.Format("({0}, {1}, {2})
　　　　　　}
　　　
　　　}
　　　　
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　Box Box1　= new Box();　　　　　　　　　　//　declarar Box1de tipo Box
　　　　　　　　Box Box2　= new Box();　　　　　　　　　　//　declarar Box2de tipo Box
　　　　　　　　Box Box3　= new Box();　　　　　　　　　　//　declarar Box3de tipo Box
　　　　　　　　Box Box4　= new Box();
　　　　　　　　double volumen = 0.0;　　　//　volumen
　　　　　　　　//　Box1　detallar
　　　　　　　　Box1.setLongitud(6.0);
　　　　　　　　Box1.setAnchura(7.0);
　　　　　　　　Box1.setHeight(5.0);
　　　　　　　　//　Box2　detallar
　　　　　　　　Box2.setLongitud(12.0);
　　　　　　　　Box2.setAnchura(13.0);
　　　　　　　　Box2.setHeight(10.0);
　　　　　　　//　usar sobrecarga de ToString() para mostrar dos cajas
　　　　　　　　Console.WriteLine("Box1： {0}1.ToString());
　　　　　　　　Console.WriteLine("Box2： {0}2.ToString());
　　　　　　　　
　　　　　　　　//　Box1　el volumen
　　　　　　　　volumen = Box1.getVolume();
　　　　　　　　Console.WriteLine("Box1　el volumen: {0}
　　　　　　　　//　Box2　el volumen
　　　　　　　　volumen = Box2.getVolume();
　　　　　　　　Console.WriteLine("Box2　el volumen: {0}
　　　　　　　　//　sumar dos objetos
　　　　　　　　Box3　Igual a Box1　+　Box2;
　　　　　　　　Console.WriteLine("Box3： {0}3.ToString());
　　　　　　　　//　Box3　el volumen
　　　　　　　　volumen = Box3.getVolume();
　　　　　　　　Console.WriteLine("Box3　el volumen: {0}
　　　　　　　　//comparando los cajas
　　　　　　　　If (Box1　> Box2)
　　　　　　　　　　Console.WriteLine("Box1　mayor que Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　No mayor que Box2");
　　　　　　　　If (Box1　< Box2)
　　　　　　　　　　Console.WriteLine("Box1　Menor que Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　No menor que Box2");
　　　　　　　　If (Box1　Mayor o igual que Box2)
　　　　　　　　　　Console.WriteLine("Box1　Mayor o igual que Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　No mayor o igual que Box2");
　　　　　　　　If (Box1　Menor o igual que Box2)
　　　　　　　　　　Console.WriteLine("Box1　Menor o igual que Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　No menor o igual que Box2");
　　　　　　　　If (Box1　Distinto de Box2)
　　　　　　　　　　Console.WriteLine("Box1　Distinto de Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Igual a Box2");
　　　　　　　　Box4　Igual a Box3;
　　　　　　　　If (Box3　Igual a Box4)
　　　　　　　　　　Console.WriteLine("Box3　Igual a Box4");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box3　Distinto de Box4");
　　　　　　　　Console.ReadKey();
　　　　　　}
　　　　}
}

Cuando el código superior se compila y ejecuta, producirá el siguiente resultado:

Box1：(6,　7,　5)
Box2：(12,　13,　10)
Box1　El volumen:　210
Box2　El volumen:　1560
Box3：(18,　20,　15)
Box3　El volumen:　5400
Box1　No mayor que Box2
Box1　Menor que Box2
Box1　No mayor o igual que Box2
Box1　Menor o igual que Box2
Box1　Distinto de Box2
Box3　Igual a Box4
Espacio de nombres (Namespace) de C#Polimorfismo de C#