Vigsimo quinta Sesin

Metodologas y Tcnicas de Programacin II

Programacin Orientada a Objeto (POO) C++

Aspectos Avanzados II
1

Programa
Introduccin a la POO Repaso de Conceptos
Historia de la Programacin Conceptos de POO Estndares de Programacin Punteros " Memoria C++ Mi primera Clase E! Control " Operadores

Clases " O#$etos en C++

%so " aplicacin Constructores Constantes e 'inline(

&unciones Amigas !o#recarga de &unciones

!o#recarga
)e Operadores Creacin )inmica de O#$etos

Herencia*

+ipos de ,isi#ilidad

Herencia M-ltiple

Polimor.ismo
&unciones ,irtuales Polimor.ismo " !o#recarga*

Plantillas

Contenedores

Iteradores

25.1 Repaso
Sobrecarga Hemos visto 0ue las .unciones pod1an ser so#recargadas* )e igual .orma los operadores tam#i2n pueden so#recargarse* En realidad la ma"or1a de los operadores en C++ estn so#recargados* Por e$emplo el operador + realiza distintas acciones cuando los operandos son enteros3 o en coma .lotante* El operador 4 se puede usar como operador de multiplicacin o como operador de indireccin* C++ permite al programador so#recargar a su vez los operadores para sus propios usos*
<tipo> operator <operador> (<argumentos>); <tipo> operator <operador> (<argumentos>) { <sentencias>; }

25.1 Repaso
class Tiempo Sobrecarga de Operadores { public: Tiempo(int h=0, int m=0) : hora_(h), minuto_(m) {} void Mostrar(); Tiempo operator+(Tiempo h); private: int hora_; int minuto_; }; Tiempo Tiempo::operator+(Tiempo h) { Tiempo temp; temp.minuto = minuto + h.minuto; temp.hora = hora + h.hora; if(temp.minuto >= 60) { temp.minuto -= 60; temp.hora++; } return temp; } } int main() { Tiempo Ahora(12,24), T1(4,45); T1 = Ahora + T1; T1.Mostrar(); (Ahora + Tiempo(4,45)).Mostrar(); return 0; } void Tiempo::Mostrar() { cout << hora << ":" << minuto << endl;

Reci#imos un parmetro por copia* Hacemos un retorno por copia* Si Tiempo t !iera p nteros sera imprescindible el constr ctor copia y el operador asignacin" 6

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

nitarios 7o 8a" parmetro* Act-a so#re 's1 mismo(* Retorno por valor* %so del puntero t8is*

25.2 Sobrecarga de Operadores

#i$erentes $ormas de Operadores ,amos a tra#a$ar con esta clase: nitarios (++)
void main() { Fraccional f1(1,2); Fraccional f2(2,1); Fraccional f3; f3 = f1 + f2 ; // Lo mismo que antes... f3 = f1.operator+( f2 ); .... .... }

class Fraccional { private: int num_ ; int den_ ; void simplificar_( ) ; public: Fraccional(int n=0, int d=1); Fraccional operator + ( Fraccional f ); Fraccional operator - (Fraccional f); Fraccional operator * (Fraccional f); Fraccional operator / (Fraccional f); int numerador( ); int denominador( ); void numerador (int n); void denominador ( int d); };

,amos a ver las di.erencias entre estas tres declaraciones e implementaciones para seguir comprendiendo la POO

void operator++(); Fraccional operator++(); Fraccional& operator++();

;

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
void operator++();

%Modi$ica el objeto receptor de la llamada& !I %#e! el!e algo& 7O Problemas' !I*

void Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; } Fraccional f1(1,1),f2; ++f1; ++(++f1); f2 = ++f1; // Nada que incrementar!! // Nada que asignar.

!i vamos a encadenar operaciones no podemos usar esta versin* En caso contrario est #ien " de 8ec8o lo estamos indicando a programadores usuario de nuestra clase <En &raccional*8=*

>

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
Fraccional operator++();

%Modi$ica el objeto receptor de la llamada& !I %#e! el!e algo& El o#$eto receptor incrementado* Problemas' !I*

Fraccional Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; return *this; } Fraccional f1(1,1),f2; ++f1; f2 = ++f1; ++(++f1); // Error.

!i vamos a encadenar operaciones de incremento no podemos usar esta versin* ,eamos por 0u2****
?

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
Fraccional operator++();

Fraccional f1(1,2); ++(++f1);

Fraccional Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; return *this; }

.1 numA 1 denA /

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
Fraccional operator++();

Fraccional f1(1,2); ++(++f1);

Fraccional Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; return *this; }

.1 numA 5 denA /

1B

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
Fraccional operator++();

Fraccional f1(1,2); ++(++f1);

Fraccional Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; return *this; }

.1 numA 5 denA /

11

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
Fraccional operator++();

Fraccional f1(1,2); ++(++f1);

Fraccional Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; return *this; }

.1 numA 5 denA /

temp1 numA 5 denA /

)evolucin por valor* Retornamos una copia del o#$eto*

1/

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
Fraccional operator++();

Fraccional f1(1,2); ++(++f1);

Fraccional Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; return *this; }

.1 numA 5 denA /

temp1 numA 9 denA /

El segundo '++( opera so#re la copia 0ue devolvi la .uncin en la llamada anterior*

15

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
Fraccional operator++();

Fraccional f1(1,2); ++(++f1);

Fraccional Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; return *this; }

.1 numA 5 denA /

temp1 numA 9 denA /

temp/ numA 9 denA /

)evolvemos por valor: Otra Copia* 7o .unciona por0ue el segundo incremento act-a so#re la copia 0ue devuelve el primero*

16

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
Fraccional& operator++();

%Modi$ica el objeto receptor de la llamada& !I %#e! el!e algo& El propio o#$eto receptor incrementado " no una copia* Problemas' 7O*

Fraccional& Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; return *this; }

Fraccional f1(1,1),f2; ++f1; f2 = ++f1; ++(++f1);

Podemos encadenar operaciones sin pro#lemas* Modi.ica el o#$eto receptor " lo devuelve como resultado* Como es una re.erencia esto" tra#a$ando con mi direccin no con una copia*
19

25.2 Sobrecarga de Operadores

Operadores nitarios y !alor de retorno(++)
Fraccional& operator++();

Fraccional f1(1,2),f2; f2 = ++f1; ++(++f1);

Fraccional& Fraccional::operator++( ) { num_ = num_ + den_; simplifica() ; return *this; }

.1 numA 1 denA / 7o 8a" o#$etos temporales* !e tra#a$a siempre con .1*

1;

25.2 Sobrecarga de Operadores

Sobrecarga' Operadores miembro ( Operadores )lobales Podemos de.inir los operadores so#re una clase de dos .ormas*
class Complejo { // Declaraciones de operadores binarios mediante funciones amigas // externas. friend ostream& operator<<(ostream& out, const Complejo& c); friend Complejo operator-(const Complejo& mi,const Complejo& md); friend Complejo operator*(const Complejo& mi,const Complejo& md); friend Complejo operator/(const Complejo& mi,const Complejo& md); public: Complejo(int re=0, int im=0); // Funciones binarias miembro de la clase internas. Complejo& operator+= (const Complejo& c); Complejo operator+(const Complejo& md); private: int re_; int im_; }

1>

25.2 Sobrecarga de Operadores

Sobrecarga' Operadores miembro ( Operadores )lobales
Complejo& Complejo::operator+= (const Complejo& c) { re_ += c.re_; im_ += c.im_; return *this; } Complejo Complejo::operator+(const Complejo& md) { return Complejo(re_ + md.re_ , im_ + md.im_); } .... Complejo operator-(const Complejo& mi, const Complejo& md) { return Complejo(mi.re_ - md.re_ , mi.im_ - md.im_); } // Me devuelvo a mi mismo.

1?

25.2 Sobrecarga de Operadores

Sobrecarga' Operadores miembro ( Operadores )lobales Como 8emos visto podemos so#recargar los operadores so#re una clase como: &unciones miem#ro* &unciones glo#ales* %n operador de tipo .uncin miem#ro re0uiere 0ue el operando de la i*+ ierda sea n objeto de la clase* %n operador de tipo .uncin glo#al permite los mismos tipos de con!ersin para am#os operandos*

1@

25.2 Sobrecarga de Operadores

Sobrecarga' Operadores miembro ( Operadores )lobales
#include Complejo.h int main() { Complejo c1(3,3); Complejo c2(4,5); Complejo c3 = c1 + c2; Complejo c4 = c3 + 5 ; Complejo c5 = 8 Complejo c6 = 1 return 0; } - c4; + c4; // Sin problemas. // Conversin del operador de la derecha. // Conversin del operador de la izquierda. // Error. Op. derecha tiene que ser Complejo.

En general es ms -til de.inir los operadores #inarios como .unciones amigas eCternas glo#ales " los unitarios como .unciones miem#ro*
/B