ALGORITMOS AVANZADOS Y ESTRUCTURA DE DATOS

SOBRECARGA

DOCENTE: PEDRO CORONADO RODRGUEZ

SOBRECARGA DE CONSTRUCTORES
Cada vez que se crea una clase o estructura, se llama a su constructor. Una clase o estructura puede tener varios constructores que toman argumentos diferentes. Los constructores permiten al programador establecer valores predeterminados, limitar la creacin de instancias y escribir cdigo flexible y fcil de leer. .

EJEMPLO: SOBRECARGA DE CONSTRUCTORES

using System; namespace practica { class Empleado { string nombre; double sueldo; double descuento; //primer mtodo sobrecargado public Empleado(string n, double s) { //Cdigo } //Segundo mtodo sobecargado public Empleado(string n, double s, double d) { //Cdigo } } class program { static void Main(string[] args) { string nombre=martin; double sueldo=2500; double descuento=100; Empleado objEmpleado_construc_0 = new Empleado(nombre, sueldo);//llama al primer constructor objEmpleado_construc_0.imprimir(); Empleado objEmpleado_construc_1 = new Empleado(nombre, sueldo, descuento);//llama al segundo constructor objEmpleado_construc_1.imprimir(); Console.ReadKey(); } } }

SOBRECARGA DE METODOS
Permite que el programador utilice el mismo nombre del mtodo en mltiples ocasiones, con argumentos diferentes en cada caso.

SOBRECARGA DE METODOS
En C#, al igual que en C++ y en Java es posible definir varios mtodos con el mismo nombre pero con distintos parmetros, de forma que el compilador decide a cul se llama dependiendo de los parmetros que le lleguen. Esto es muy prctico, pues no tienes que renombrar cada funcin segn el tipo de valor que acepta. El siguiente ejemplo implementa un par de mtodos que elevan al cuadrado el valor que reciben, y se implementan para tipos double y para int.

SOBRECARGA DE METODOS
using System; class Eleva { public static double AlCuadrado( int a ) {return a*a;} public static double AlCuadrado( double a ) {return a*a;}

} class Principal{ public static void Main() { Console.WriteLine("4 al cuadrado es {0}", Eleva.AlCuadrado(4) ); Console.WriteLine("3.2 al cuadrado es {0}", Eleva.AlCuadrado(3.2) ); Console.ReadKey(); } }

SOBRECARGA DE OPERADORES
La sobrecarga de operadores es la capacidad para transformar los operadores de un lenguaje como por ejemplo el +, -, etc, cuando se dice transformar se refiere a que los operandos que entran en juego no tienen que ser los que admite el lenguaje por defecto. Mediante esta tcnica podemos sumar dos objetos creados por nosotros o un objeto y un entero, en vez de limitarnos a sumar nmeros enteros o reales

SOBRECARGA DE OPERADORES
Algunos operadores pueden ser sobrecargados. Aunque la finalidad es la misma, la sintaxis para declarar la sobrecarga de operadores difiere en su sintaxis con respecto a la de los mtodos. C# permite la sobrecarga de operadores definiendo mtodos estticos que usan la palabra operator. No todos los operadores pueden sobrecargarse y, de los que se pueden, algunos tienen restricciones. A continuacin se listan los operadores que pueden sobrecargarse y las restricciones existentes para algunos de ellos.

SOBRECARGA DE OPERADORES
Operadores unarios. + , - , ! , ++ , -- , true , false Operadores binarios. + , - , * , / , % , & , | , ^ , << , >> Operadores relacionales ( condicionales ). = = , != , < , > , <= , >= Los operadores relacionales deben sobrecargarse por parejas; esto es, si se sobrecarga = = , tambin debe sobrecargarse != . Lo mismo se aplica a < y > , y a <= y >= . Operadores lgicos. && , ||

SOBRECARGA DE OPERADORES
Sintaxis para la sobrecarga de operadores. [modificadores] <nombreClase> operator <nombreOperador> ( [parmetros] ) { // Cuerpo }

SOBRECARGA DE OPERADORES
//Sobrecarga los operadores + y * para sumar y multiplicar //Nmeros fraccionarios. using System; class Fraccion { public int num, den; public Fraccion(int n, int d) { num = n; den = d; } public Fraccion() { } public static Fraccion operator +(Fraccion x, Fraccion y) { return new Fraccion(x.num * y.den + y.num * x.den, x.den * y.den); } public static Fraccion operator *(Fraccion x, Fraccion y) { return new Fraccion(x.num * y.num, x.den * y.den); } public static explicit operator double(Fraccion f) //Convierte a double. { return (double)f.num / f.den; } } class Principal { public static void Main() { Fraccion x = new Fraccion(1, 4); Fraccion y = new Fraccion(3, 2); Fraccion r = new Fraccion(); r = x + y; Console.WriteLine(r.num + "/" + r.den); Console.WriteLine("{0:F3}", (double)(x + y)); Console.WriteLine("{0:F3}", (double)(x * y)); } }