Como sobrecargar operadores

La sobrecarga de un operador es una caracterstica del polimorfismo que debe poseer un lenguaje orientado a objetos. Consiste bsicamente en hacer que un operador acte de acuerdo al tipo de objetos a los cuales se aplica. Por ejemplo, el operador + en C# tiene al menos dos sobrecargas bien conocidas: suma de nmeros y concatenacin de cadenas. Si se aplica a dos valores numricos retorna el resultado de la suma de esos nmeros, as,
suma = 3 + 5;

en la variable suma se almacena el valor 8. En cambio si se aplica a dos cadenas de texto, retorna como resultado la concatenacin de dichas cadenas,
cadena = Hola + mundo;

en la variable cadena se almacena el valor Holamundo Por lo tanto, el operador + ha realizado operaciones de acuerdo al tipo de datos que representen sus operandos: si es nmero realiza una adicin y si es cadena realiza una concatenacin.

La clase Complejo
En seguida vamos a desarrollar un ejemplo prctico que nos permitir conocer como se sobrecarga un operador en C#. Para ello vamos a jugar con los nmeros complejos que en matemticas tienen la forma

a + bi
donde a y b son nmeros reales, conocidos como parte real y parte imaginaria respectivamente, e

i = 1 .
Los nmeros complejos son una ampliacin del concepto de nmero real, que permiten resolver problemas donde se trabaja con valores que no siempre se pueden representar en la recta real sino que requieren ubicarse en un plano cartesiano, convirtiendo a los reales en un caso particular de estos. Como tal, estos nmeros admiten cualquier operacin matemtica, al igual que los nmeros reales, tales como: la suma, la multiplicacin, la divisin y la resta, entre otras.
Eje imaginario

a + bi b

a Eje real

En la prctica los nmeros complejos son una forma matemtica de manipular puntos en el plano como si se tratara de cualquier nmero. Esta caracterstica hace que estos nmeros tengan una basta aplicacin en

www.pedrov.phpnet.us

ingeniera, ya que le facilitan al ingeniero la realizacin de una diversidad de operaciones relacionadas con el manejo de puntos en el plano. Existen algunas operaciones propias de estos nmeros, como es el conjugado de un nmero complejo. El problema es que .NET es una plataforma abierta y no exclusivamente matemtica, por lo tanto no ha dispuesto de los operadores adecuados para trabajar con este tipo de valores. Para resolver el problema vamos a definir una clase que sirva de plantilla para generar los nmeros complejos. Una clase de este tipo, bsicamente debe trabajar con dos datos numricos, la parte real y la parte imaginaria del complejo. Inicialmente, la clase que se llamar Complejo, puede tener la siguiente forma:
public class Complejo { // Atributos de la clase double real; double imaginario; // Constructor public Complejo() {} // Propiedades public double Real { get { return real; } set { real = value; } }

// Devuelve el valor de real // Asigna a real un valor ingresado

public double Imaginario { get { return imaginario; } set { imaginario = value; } } }

En estas condiciones un objeto definido a partir de esta clase, solo puede guardar y devolver su parte real y su parte imaginaria. Si el programador necesita realizar cualquier operacin deber hacerlo en la clase donde se utilice un objeto de este tipo. Vamos a dotar a cada elemento derivado de esta clase de las cualidades necesarias que lo hagan autosuficiente, y capaz de resolver sus propios problemas.

El conjugado de un complejo con el operador !

El conjugado de un nmero complejo es otro complejo cuya parte imaginaria es opuesta a la del primero. As, dado un complejo, z = a + bi su conjugado es z = a bi . Por ejemplo, el conjugado de z = 5 + 3i es z = 5 3i , o tambin, el conjugado de 2 - 5i es 2 + 5i. En resumen, el conjugado de un complejo se obtiene invirtiendo el signo de su parte imaginaria. En C# para codificar el conjugado vamos a utilizar el operador ! (negacin). Sabemos que en C# este operador se utiliza para invertir el valor booleano de una expresin de este tipo, la cual no se parece en nada a el conjugado de un complejo. No existe una razn directa para que este operador se haya escogido como conjugado, pudo haber sido cualquier otro. En nuestro caso deseamos que cuando se aplique este operador a un complejo, lo transforme a su conjugado y que este comportamiento lo tenga nicamente cuando se aplique a este tipo de nmeros.

www.pedrov.phpnet.us

La solucin al problema antes planteado, es sobrecargar el operador en mencin. Para definir la sobrecarga se necesita un mtodo esttico del operador implicado. En este caso particular, como el resultado de aplicar el operador es un nmero complejo, este mtodo debe ser del tipo Complejo.
public static Complejo operator !(Complejo z) { // Declarar una variable Complejo para guardar el resultado Complejo conjugado = new Complejo(); // Invertir el signo de la parte imaginaria del complejo de entrada double iz = 0; iz = - z.Imaginario; // Construir el complejo conjugado a partir de z conjugado.Real = z.Real; conjugado.Imaginario = iz; // Devolver el complejo conjugado return conjugado; }

Observe que, el operador recibe como valor de entrada el complejo sobre el cual actuar, y la operacin bsica que realiza es invertir el signo de su parte imaginaria. Con esto tenemos una nueva aplicacin para el operador !. A partir de aqu, cuando se aplique el operador a los nmeros complejos definidos a partir de la clase Complejo, se obtendr el conjugado de dicho nmero.

Suma de complejos con el operador +

Para asignarle al operador + la posibilidad de sumar complejos, se debe tener en cuenta que la suma se define de la siguiente manera: Dados dos complejos z = a + bi y w = c + di , la suma es,

z + w = (a + c) + (b + d )i
As, por ejemplo, dados z = 3 + 2i y w = 10 + 4i , la suma es z + w = 13 + 6i . Entonces siguiendo un anlisis similar al conjugado, la sobrecarga del operador + la podemos hacer mediante el siguiente mtodo:
public static Complejo operator +(Complejo z1, Complejo z2) { Complejo suma = new Complejo(); suma.Real = z1.Real + z2.Real; suma.Imaginario = z1.Imaginario + z2.Imaginario; return suma; }

Cuando se aplique el operador + a dos nmeros complejos se obtendr la suma compleja de los mismos. Pero el operador seguir realizando las mismas operaciones que venia haciendo, cuando se aplique a otros tipos, como nmeros reales o cadenas. Esto es lo que se llama un comportamiento polimrfico de los operadores
Presentacin del complejo

www.pedrov.phpnet.us

Por ltimo, y al margen del objetivo de este tema (solo por cuestiones de presentacin) vamos a definir un mtodo para mostrar en pantalla un nmero complejo al estilo de las matemticas. Este bien podra ser como sigue:
// Mtodo para formatear el nmero complejo public string Mostrar() { string cadenaReal = ""; string cadenaImaginario = ""; cadenaReal = Convert.ToString(real); cadenaImaginario = Convert.ToString(Math.Abs(imaginario)); if (imaginario > 0) return cadenaReal + " + " + cadenaImaginario + "i"; else if (imaginario < 0) return cadenaReal + " - " + cadenaImaginario + "i"; else return cadenaReal; }

Reuniendo en una clase los anteriores bloques de cdigo, tenemos el tipo que nos permitir definir nuestros nmeros complejos:
/* Archivo: Complejo.cs */ using System; public class Complejo { // Atributos de la clase double real; double imaginario; // Constructor public Complejo() {} // Propiedades public double Real { get { return real; } // Devuelve el valor de real set { real = value; } // Asigna a real un valor ingresado } public double Imaginario { get { return imaginario; } set { imaginario = value; } } // Sobrecargar el operador ! para obtener el conjugado de un complejo public static Complejo operator !(Complejo z) { Complejo conjugado = new Complejo(); double iz = 0; iz = - z.imaginario; conjugado.Real = z.Real; conjugado.Imaginario = iz; return conjugado; } // Sobrecargar el operador + para sumar dos nmeros complejos public static Complejo operator +(Complejo z1, Complejo z2) { Complejo suma = new Complejo(); suma.Real = z1.Real + z2.Real;
www.pedrov.phpnet.us 4

suma.Imaginario = z1.Imaginario + z2.Imaginario; return suma; } // Mtodo para formatear el nmero complejo public string Mostrar() { string cadenaReal = ""; string cadenaImaginario = ""; cadenaReal = Convert.ToString(real); cadenaImaginario = Convert.ToString(Math.Abs(imaginario)); if (imaginario > 0) return cadenaReal + " + " + cadenaImaginario + "i"; else if (imaginario < 0) return cadenaReal + " - " + cadenaImaginario + "i"; else return cadenaReal; } }

Guarde este archivo con el nombre Complejo.cs y complelo en una librera dinmica, mediante la instruccin de lnea de comandos,
> csc /t:library Complejo.cs

Para probar esta librera puede utilizarse el siguiente programa:

/* Archivo: test.cs */ using System; class NumerosComplejos { static void Main() { Complejo z1 = new Complejo(); Complejo z2 = new Complejo(); Complejo zsuma = new Complejo(); // Cargar los datos de un nmero complejo convirtiendo // las entradas de texto a valores numricos Console.Write("Parte real: "); z1.Real = Convert.ToDouble(Console.ReadLine()); Console.Write("Parte imaginaria: "); z1.Imaginario = Convert.ToDouble(Console.ReadLine()); // Mostrar el nmero complejo z1 Console.WriteLine("z1 = {0}", z1.Mostrar()); // Calcular el conjugado de z1 y asignarlo a z2 z2 = !z1; // Mostrar el nmero complejo z2 Console.WriteLine("z2 = {0}", z2.Mostrar()); // Sumar dos veces el mismo complejo zsuma = z1 + z1; Console.WriteLine("z1 + z1 = {0}", zsuma.Mostrar()); // Sumar un complejo con su conjugado zsuma = z1 + z2; Console.WriteLine("z1 + z2 = {0}", zsuma.Mostrar()); } }

Guarde el archivo con el nombre test.cs y complelo con la instruccin de lnea de comandos,

www.pedrov.phpnet.us

> csc /r:complejo.dll test.cs

Puede modificar el programa de prueba, incluyendo aplicaciones del operador ! en operaciones booleanas y ver que sigue haciendo lo que le corresponde hacer para ese tipo de objetos.

www.pedrov.phpnet.us