Está en la página 1de 17

Dcimoquinta Sesin

Metodologas y Tcnicas de Programacin II

Programacin Orientada a Objeto (POO) C++

Sobrecarga de Operadores II
1

15.2 Sobrecarga de Operadores II


Sobrecarga de operadores nitarios (o narios) Son aquellos operadores que slo requieren un operando. Asignacin. = Incremento. ++ Otros.... En los operadores binarios el primer argumento era el propio objeto de la clase donde se define el operador. En los operadores unitarios: El operando es el propio objeto. o requieren operandos !dentro de una clase".

<tipo> operator<operador unitario>();

15.2 Sobrecarga de Operadores II


Sobrecarga de operadores
{ ... Tiempo operator++(); ... }; Tiempo Tiempo::operator++() { minuto++; while(minuto >= 60) { minuto -= 60; hora++; } return *this; } ... ++T1;

nitarios

class Tiempo

15.2 Sobrecarga de Operadores II


Operadores nitarios s !ijos '(mo es el En el ejemplo anterior %emos &isto preincremento. postincremento) !*er diferencia ++i + i++"

,egla: si se declara un par-metro para un operador ++ .. se sobrecargarla forma sufija del operador. El par-metro se ignorar-+ as/ que bastar- con indicar el tipo. (uando se usa un operador en la forma sufijo dentro de una e0presin+ primero se usa el &alor actual del objeto+ 1 una &e2 e&aluada la e0presin+ se aplica el operador. 3rimero de&ol&emos el &alor actual 1 luego incrementamos !*er i++". Si nosotros queremos que nuestro operador act4e igual deberemos usar un objeto temporal+ 1 asignarle el &alor actual del objeto. Seguidamente aplicamos el operador al objeto actual 1 finalmente retornamos el objeto temporal.

15.2 Sobrecarga de Operadores II


Sobrecarga de operadores
class Tiempo { ... Tiempo operator++(); // Prefijo Tiempo operator++(int); // Sufijo ... }; Tiempo Tiempo::operator++() { minuto++; while(minuto >= 60) { minuto -= 60; hora++; } return *this; } T1.Mostrar(); T1.Mostrar(); T1.Mostrar(); // 01:01 // 01:02 // 01:03 (T1++).Mostrar(); // 01:01 (++T1).Mostrar(); // 01:03 } } return temp;

nitarios
Tiempo Tiempo::operator++(int) { //Constructor copia Tiempo temp(*this); minuto++; while(minuto >= 60) { minuto -= 60; hora++;

15.2 Sobrecarga de Operadores II


Operadores de con"ersin de Tipos Suponed que queremos poder %acer esto: 7iempo 71!1#+#$"8 unsigned int minutos = 5$#8 71 += minutos8 7iempo!int %=9+ int m=9" : %ora!%"+ minuto!m" :; << (onstr. En (++ se reali2an con&ersiones impl/citas entre los tipos b-sicos antes de operar con ellos+ por ejemplo para sumar un int 1 un float+ se con&ierte el entero a float. Se utili2a el constructor que tenemos. (omo slo %a1 un par-metro en la llamada+ el par-metro m toma el &alor 9+ 1 para el par-metro% se con&ierte el &alor =minutos= de unsigned int a int. El resultado es que se suman 5$# %oras+ 1 nosotros queremos sumar 5$# minutos.
>

15.2 Sobrecarga de Operadores II


Operadores de con"ersin de Tipos (omo nosotros queremos sumar a los minutos necesitamos crear un nue&o constructor.
Tiempo(unsigned int m) : hora(0), minuto(m) { while(minuto >= 60) { minuto -= 60; hora++; } }

En general podremos %acer con&ersiones de tipo desde cualquier objeto a un objeto de nuestra clase sobrecargando el constructor. !3or ejemplo si consideramos float como milisegundos ? Ejercicio". '@ al re&As) Buiero asignar a un entero un objeto de tipo 7iempo. int minutos = 718 << Error de compilacin.
C

15.2 Sobrecarga de Operadores II


Operadores de con"ersin de Tipos int minutos = 718 << Error de compilacin. 7enemos que diseDar nuestro operador de con&ersin de tipo+ que se aplicar- autom-ticamente en esas llamadas.
class Tiempo { ... operator int(); ... operator int() { return hora*60+minuto; }

o necesitan que se especifique el tipo del &alor de retorno+ 1a que este es precisamente EtipoF. Al ser operadores unitarios+ tampoco requieren argumentos+ porque se aplican al propio objeto. #l tipo p ede ser c al$ ier clase o estr ct ra%
G

15.2 Sobrecarga de Operadores II


Operador Inde&acin '( El operador HI se usa para acceder a &alores de objetos de una determinada clase como si se tratase de arra1s. Jos /ndices no tienen por quA ser de un tipo entero o enumerado. A%ora no e0iste esa limitacin. Ka1or utilidad con estructuras din-micas de datos: Jistas 1 -rboles. Arra1s asociati&os+ donde los /ndices sean por ejemplo+ palabras *eamos un ejemplo. Supongamos que %acemos una clase para %acer un %istograma de los &alores de rand!"<,A LMKAN+ entre los m-rgenes de 9 a 9.999O+ de 9.991 a 9.99O+ de 9.91 a 9.9O 1 de 9.1 a 1. Jo que queremos es saber cu-ntos &alores caen entre cada uno de los rangos.
O

15.2 Sobrecarga de Operadores II


Operador '(
class Cuenta { public: Cuenta() { for(int i = 0; i < 4; contador[i++] = 0); } int &operator[](double n); void Mostrar() const; private: int contador[4]; }; int &Cuenta::operator[](double n) { if(n < 0.001) return contador[0]; else if(n<0.01) return contador[1]; else if(n<0.1) return contador[2]; else return contador[3]; } } int main() { Cuenta C; for(int i = 0; i < 50000; i++) C[(double)rand()/RAND_MAX]++; C.Mostrar(); return 0; void Cuenta::Mostrar() const { cout << "Entre 0 y 0.0009: " << contador[0] << endl; cout << "Entre 0.0010 y 0.0099: " << contador[1] << endl; cout << "Entre 0.0100 y 0.0999: " << contador[2] << endl; cout << "Entre 0.1000 y 1.0000: " << contador[3] << endl;

19

15.2 Sobrecarga de Operadores II


Operador Inde&acin '( En el ejemplo %emos usado un &alor double como /ndice+ pero igualmente podr/amos %aber usado una cadena o cualquier objeto que %ubiAsemos querido. El tipo del &alor de retorno de operador debe ser el del objeto que de&uel&e En nuestro caso+ al tratarse de un contador+ de&ol&emos un entero. En realidad de&ol&emos una referencia a un entero+ para poder aplicarle el operador de incremento al &alor de retorno. (uando se combina el operador de inde0acin con estructuras din-micas de datos como las listas+ se puede trabajar con ellas como si se tratada de arra1s de objetos+ esto nos dar- una gran potencia 1 claridad en el cdigo de nuestros programas. Jista miMlista8 miMlistaH19I.mostrar!"8 miMlistaHP3ere2QI.mostrar!"8

11

15.2 Sobrecarga de Operadores II


Operador llamada () Runciona igual que el operador HI. Admite m-s par-metros. 3ermite usar un objeto de la clase para el que est- definido como si fuera una funcin. HI slo admite un par-metro entre los corc%etes. !" admite los que definamos. Jista miMlista8 ...... miMlistaH6I.mostrar!"8 ...... cout EE PL I de Sose 3ere2Q EE miMlista!PSosAQ+ P3Are2Q" EE endl8 ......
1#

15.2 Sobrecarga de Operadores II


Operador llamada ()
class Cuenta { ... int operator()(double n, double m); ... }; int Cuenta::operator()(double n, double m) { int i, j; if(n < 0.001) i = 0; else if(n < 0.01) i = 1; else if(n < 0.1) i = 2; else i = 3; if(m < 0.001) j = 0; else if(m < 0.01) j = 1;

Por supuesto, el nmero de parmetros, al igual que el tipo de retorno de la funcin depende de la decisin del programador.

else if(m < 0.1) j = 2; else j = 3; if(contador[i] > contador[j]) return contador[i]; else return contador[j]; }

1$

15.3 Repaso
)epaso Ja sobrecarga de operadores es simplemente otra forma que tenemos para reali2ar llamadas a funciones. Jos argumentos para estas funciones no aparecen entre parAntesis+ sino que rodean o siguen a los caracteres que siempre pensamos como operadores inalterables ! + + ++ + HI". En (++ es posible deTnir nue&os operadores que trabajen con clases. Esta deTnicion es e0actamente como la deTcin de una funcion ordinaria+ e0cepto que el nombre de la funcion consiste en la palabra reser&ada operator seguida del operador. #sta es la *nica di!erencia% El operador se con&ierte en una funcion como otra cualquiera que el compilador llama cuando &e el prototipo adecuado.
15

15.3 Repaso
)epaso o %a1 ra2on para sobrecargar un operador e0cepto si eso %ace al cdigo implicado con la clase m-s sencillo e intuiti&o de escribir 1 especialmente de leer. (uidado+ porque es tentador usar operadores Ppor todas partesQ. unca podremos sobrecargar operadores as/: 3ara rematar: Jeed el cap/tulo 1# del libro P3ensar en (++Q Jo &eremos en la parte de aspectos a&an2ados. 1 EE 58

16

15.4 Ejercicios
Clase Complejo Implementar la clase de los n4meros complejos sobrecargando operadores de forma que podamos usarla como se e0pone en el main!".
class Complejo { private: int real_; int imaginaria_; public: ....... } int main() Complejo a(1,1), b(2,2); Complejo c(b); cout << cout << cout << cout << c = a + cout << b = a cout << ++ c c -- Parte Parte b; c; c; b; << ++c; << c--; Imaginaria de c << c[1]; Real c << c[0];

1>

15.4 Ejercicios
Clase Persona Implementar la clase 3ersona sobrecargando los operadores =+ + 1 EE teniendo en cuenta que tienen punteros 1 que la suma de dos personas nos da otra persona cu1o nombre es la suma de los nombres de los sumandos 1 su altura es la ma1or de las dos alturas de los sumandos.
class Persona { private: int altura_; char* nombre_; public: ....... }

Tener en cuenta que hacen falta constructores, constructores copia y destructores. Hacer lo necesario para poder asignar un entero a una persona de forma que el nombre es esos casos sea Fabian y la altura sea la de la asignacin. Persona p(Pepe,3); p = 5; cout << p << endl; 1C