Informática II

1. Informática II Clase 6: Funcionesavanzadas Diego Fernando Serna Restrepo Semestre 2011/2

2. Chiste del Día Informática II 2011/2

3. Manejo de errores • ¿Qué haría su programa si causa uno de los más comunes errores matemáticos, división por cero? • Sus opciones incluyen: • Romper el flujo del programa. • Informar al usuario y salir con elegancia. • Informar al usuario y permitirle tratar de recuperarse y continuar. • Tomar medidas correctivas y continuar sin perturbar a el usuario. Informática II 2011/2

4. Excepciones Informática II 2009/2

5. Bloques try-catch • Se pueden tener múltiples bloques catch después del bloque try, donde cada uno se hace cargo de un tipo diferente de error, asemejándose a los casos de una sentencia switch. Informática II 2011/2

6. Bloque try-catch Informática II 2011/2

7. throw Informática II 2011/2

8. Contenido Poliformismo 1 Inicialización de variables miembro 2 Constructores Copia 3 Sobrecarga de operadores 4 Informática II 2011/2

9. Sobrecargado de funciones (Polimorfismo) • Consiste en crear diferentes funciones con el mismo nombre, con el fin de ofrecer al usuario una manera más sencilla de recordar las funciones. //Algunos protototipos intfuncion(int); intfuncion(long, long); intfuncion(long); /* El programa determina cual de las funciones “funcion” ha sido llamada, según los parámetros con que sea llamada la función*/ Informática II 2011/2

10. Sobrecargado de los métodos de las clases • Los métodos de las clases también pueden ser sobrecargados como el resto de las funciones, su sintaxis es prácticamente igual. classRectangulo { public: // función DibujarFigura() sobrecargada de la clase voidDibujarFigura() const; voidDibujarFigura(intunAncho, intunaAltura) const; private: intsuAncho; intsuAltura; }; voidDibujarFigura() const; voidDibujarFigura(intunAncho, intunaAltura) const; Informática II 2011/2

11. Sobrecargado de los métodos de las clases • Los constructores, al ser métodos especiales de las clases también pueden ser sobrecargados, y la manera de hacerlo es igual que el resto de los métodos. • ¡OJO!, los destructores no pueden ser sobrecargados, ¿Porque? Informática II 2011/2

12. Ejemplo Polimorfismo carro::carro(){ gGas=0; marca=0; velMax=0; vel=0; start=false; } void carro::acelerar(){ if(--gGas<=0){ vel=0; } else{ vel++; } } class carro{ private: intgGas; char *marca; intvelMax; intvel; boolstart; public: carro(); carro(int _gGas,char *_marca="mazda",\ int _velMax=80); void arrancar(); void acelerar(); void acelerar(intincrement); void frenar(); intgetVel() const; ~carro(); }; carro::carro(int _gGas,char *_marca, int _velMax){ gGas=_gGas; marca=_marca; velMax=_velMax; vel=0; } void carro::acelerar(intincrement){ if(gGas-=increment<=0){ vel=0; } else{ vel++; } } Informática II 2011/2

13. Valores por defecto Informática II 2011/2

14. Valores por defecto Informática II 2011/2

15. Contenido Poliformismo 1 Inicialización de variables miembro 2 Constructores Copia 3 Sobrecarga de operadores 4 Informática II 2011/2

16. Inicialización de las variables miembro • Las variables miembro pueden ser inicializadas tanto en la etapa de inicialización de métodos, como en el cuerpo de éstos. //Etapa de inicialización Gato::Gato(): suEdad(5), suPeso(8) { //Cuerpo del constructor } //Nombre y parámetros del constructor Informática II 2011/2

17. Inicialización de las variables miembro Informática II 2011/2

18. Contenido Poliformismo 1 Inicialización de variables miembro 2 Constructores Copia 3 Sobrecarga de operadores 4 Informática II 2011/2

19. Constructor Copia • Adicionalmente de ser asignado por defecto un constructor y un destructor cuando no son declarados explícitamente en la declaración de la clase, el compilador provee un constructor de copia, que es llamado cada vez que se requiere una copia de un objeto. #include <iostream> usingnamespacestd; carro Deportivo(10,"BMW",50); //carro carreras=Deportivo; carro carreras(Deportivo); //constructor copia por defecto intmain() { cout<<Deportivo.getVelMax()<<endl; cout<<carreras.getVelMax()<<endl; return 0; } 50 50 Informática II 2011/2

20. Constructores de copia • Cada vez que se crea una copia de un objeto "El constructor de copia” es ejecutado. • Por defecto, el constructor de copia simplemente copia cada miembro de una objeto hacia el nuevo objeto. Esta copia se denomina “Copia Superficial”. //Declaración del constructor de copia GATO (const GATO &); // constructor de copia Informática II 2011/2

21. Constructores de copia La copia superficial es buena para casi todo tipo de variables; sin embargo, es muy fácil de romper cuando los miembros son punteros a objetos en el Heap. Informática II 2011/2

22. Constructores de copia • La solución para evitar problemas ocasionados por las copias superficiales, es usando los constructores de copia para que estos hagan la copia en diferentes espacios del Heap, realizando lo que se denomina como “Copia Profunda”. Informática II 2011/2

23. Constructores de copia Informática II 2011/2

24. Constructores de copia Informática II 2011/2

25. Ejemplo Clase Copia #include <iostream> usingnamespacestd; char marca[]= "BMW”; carro Deportivo(10,marca,50); carro carreras(Deportivo); //carro carreras=Deportivo; intmain() { cout<<Deportivo.getVelMax()<<endl; cout<<carreras.getVelMax()<<endl; return 0; } //El otro constructor //inicialización en la etapa de inicialización carro::carro(int _gGas,char *_marca, int _velMax): marca(_marca), velMax(_velMax){ gGas=new int; *gGas=_gGas; } // Declaración de los otros métodos int carro::getVelMax() const{ returnvelMax; } carro::~carro(){ //Destructor deletegGas; gGas=0; //NULL } //constructor por defecto //incializacion en la etapa de inicialización carro::carro():gGas(0),marca(0),velMax(0),\ vel(0), start(false){ gGas=new int; } classcarro{ private: int *gGas; char *marca; constintvelMax; intvel; boolstart; public: carro(); carro(int _gGas,char *_marca,int _velMax); //se declara el constructor de copia. carro(carro &original); void arrancar(); void acelerar(); void acelerar(intincrement); void frenar(); intgetVel() const; intgetVelMax() const; intgetgGas() const; voidsetVelMax(intvel); ~carro(); }; 50 50 //la variable constante debe ser inicializada en la etapa de inicialización igualmente en el constructor de copia. //constructor de copia carro::carro(carro &original):velMax(original.getVelMax()){ //se hace una copia de cada una de las variables miembro marca=original.marca; vel=original.vel; start=original.start; gGas=new int; *gGas=original.getgGas(); } Informática II 2011/2

26. Contenido Poliformismo 1 Inicialización de variables miembro 2 Constructores Copia 3 Sobrecarga de operadores 4 Informática II 2011/2

27. Sobrecargado de los operadores • La sobrecarga de operadores quiere decir que se pueden redefinir algunos de los operadores existentes en C++ para que actúen de una determinada manera, definida por el programador, con los objetos de una clase creada por el mismo. • La sobrecarga de operadores se emplea para declarar “como es que funciona” dicho operador cuando se utilizan sobre los objetos. 2+1=0 Informática II 2011/2

28. Sobrecarga de operadores • El objetivo de la sobrecarga de operadores es simplificar al máximo el código a escribir, a cambio de complicar algo la definición de las clases. Una clase que disponga de operadores sobrecargados es una clase más compleja de definir, pero más sencilla e intuitiva de utilizar. Informática II 2011/2

29. Sobrecarga de operadores • La sobrecarga de un operador puede ser declarada de la siguiente forma: tipodeRetornooperatorop (parametros); Void, int, char, … Palabra reservada -, --, + , ++, =, ==, … Void, int, char, … voidoperator ++ (); // Ejemplo de una declaración para el sobrecargado del operador ++ Informática II 2011/2

30. Ejemplo Sobrecarga del operador Prefijo usingnamespacestd; contador mycontador(); intmain() { mycontador.incrementar(); cout<<"incremento utlizandounmetodo: " \ << mycontador.getvariable()<<endl; ++mycontador; cout<<"incremento sobrecargandoel operador ++:" \ <<mycontador.getvariable()<<endl; return 0; } contador::contador():variable(0){} //constructor de copia contador::contador(contador& original){ variable=original.variable; } int contador::getvariable() const{ returnvariable; } void contador::setvariable(int _variable){ variable=_variable; } void contador::incrementar(){ ++variable; } class contador{ private: int variable; public: contador(); //constructor de copia contador(contador& original); intgetvariable() const; voidsetvariable(int _variable); void incrementar(); //sobrecarga el operador //preincremento (++i) voidoperator ++(); ~contador(); }; 0 1 //definición de la sobrecarga del operador preincremento (++i) void contador::operator++(){ ++variable; } //Destructor contador::~contador(){} Informática II 2011/2

31. Ejemplo Sobrecarga del operador Prefijo • Ahora lo que generalmente se desea es poder es retornar un objeto tipo contador, de este modo poder reasignarlo a otro objeto tipo contador. //definición de la operador preincremento (++i) contador contador::operator++(){ ++variable; contador temp; temp.setvariable(variable); returntemp; } usingnamespacestd; contador cont1; intmain() { cont1.incrementar(); cout<<"cont1: " <<cont1.getvariable()<<endl; contador cont2=++cont1; cout<<"cont2: "<<cont2.getvariable()<<endl; return 0; } cont1: 1 cont2: 2 Informática II 2011/2

32. Ejemplo Sobrecarga del operador Prefijo • Pero por qué crear un objeto temporal?, recordemos que cada objeto temporal debe ser construido, destruido, y copiado luego del retorno del método, siendo cada operación de estas muy costosa computacionalmente hablando. • El objeto cont1 ya existe y posee un valor adecuado para variable, porque no ratonarlo a sí mismo mediante el puntero this(*this es el objeto, mientras que thises su dirección) //definición de la operador preincremento (++i) const contador& contador::operator++(){ ++variable; return *this; } Informática II 2011/2

33. Ejemplo Sobrecarga del operador Prefijo En esta línea de código se presenta los siguientes pasos: contador cont2=++cont1; Informática II 2011/2

34. Sobrecargado del operador posfijo • Los operadores posfijos son los que primero devuelven el valor y luego opera la variable, ejemplo: i++; • Para sobrecargar el operador posfijo en los objetos, es necesario el uso de objetos temporales dentro de los métodos para luego devolverlos por valor. Informática II 2011/2

35. Sobrecargado del operador posfijo • Declaración const Contador Contador::operator++(intflag) { Contador temp(*this); ++itsVal; returntemp; } /* Notese el uso de la variable flag... dicha vble es declarada pero ¡¡nunca es utilizada!! */ flagtipoint tiene valor 0 y no se utiliza nunca, solo sirve como criterio de distinción frente al operador de preincremento. Informática II 2011/2

36. Sobrecarga del operador de Postincremento De este modo, el valor del objeto será modificado, pero en la expresión donde aparezca se tomará el valor antes de modificar. Informática II 2011/2

37. Ejemplo Sobrecarga del operador Posfijo //Constructor contador::contador():variable(0){} //constructor de copia contador::contador(contador& original){ variable=original.variable; } int contador::getvariable() const{ returnvariable; } void contador::setvariable(int _variable){ variable=_variable; } void contador::incrementar(){ ++variable; } //definicion de la operador preincremento (++i) const contador& contador::operator++(){ ++variable; return *this; } //definicion del operador posincremento (i++) const contador contador::operator++(intflag){ //hace una copia del objeto contador temp(*this); ++variable; returntemp; } usingnamespacestd; contador cont1; //Ejemplo operador posincremento intmain() { cont1.incrementar(); cout<<"incremento utlizando un metodo: "<< cont1.getvariable()<<endl; contador cont2=++cont1; cout<<"El valor de cont1 luego de preincremento "<<cont1.getvariable()<<endl; cout<<"El valor de cont2: "<<cont2.getvariable()<<endl; cont2=cont1++; cout<<"El valor de cont2: "<<cont2.getvariable()<<endl; cout<<"El valor de cont1 luego de posincremento: "<<cont1.getvariable()<<endl; return 0; } cont1: 1 cont1: 2 cont2: 2 cont2: 2 cont1: 3 class contador{ private: int variable; public: contador(); //constructor de copia contador(contador& original); intgetvariable() const; voidsetvariable(int _variable); void incrementar(); //sobrecarga el operador preincremento(++i) const contador& operator ++(); //sobrecarga del operador posincremento(i++) const contador operator ++(intflag); ~contador(); }; Informática II 2011/2

38. Sobrecarga de operadores Informática II 2011/2

39. Operadores Binarios • son aquellos que requieren dos operandos, como la suma o la resta. Cuando se sobrecargan operadores en el interior se asume que el primer operando es el propio objeto de la clase donde se define el operador. Debido a esto, sólo se necesita especificar un operando como argumento. Informática II 2011/2

40. Sobrecargando el operador + usingnamespacestd; //Ejemplo operador + intmain() { contador cont1(5),cont2(6); contador cont3=cont1+cont2; cout<<"el valor de cont1 es: "<<cont1.getvariable()<<endl; cout<<"el valor de cont2 es: "<<cont2.getvariable()<<endl; cout<<"el valor de cont3 es: "<<cont3.getvariable()<<endl; return 0; } contador::contador():variable(0){} contador::contador(int _variable): variable(_variable){} //constructor de copia contador::contador(contador& original){ variable=original.variable; } int contador::getvariable() const{ return variable; } void contador::setvariable(int _variable){ variable=_variable; } void contador::incrementar(){ ++variable; } cont1: 5 cont2: 6 cont3: 11 class contador{ private: int variable; public: contador(); contador(int _variable); //constructor de copia contador(contador& original); intgetvariable() const; voidsetvariable(int _variable); void incrementar(); //sobrecarga el operador + contador operator +(const contador& other); ~contador(); }; //definición del operador + contador contador::operator +(const contador& other){ contador temp; temp.setvariable(variable+other.getvariable()); returntemp; } contador::~contador(){} Informática II 2011/2

41. Sobrecargando el operador = int main() { contador cont1(5),cont2(6); cont2=cont1; cout<<"el valor de cont1 es: "<<cont1.getvariable()<<endl; cout<<"el valor de cont2 es: "<<cont2.getvariable()<<endl; return 0; } • Qué pasa si el objeto cont1 tiene como variables miembro punteros que acceden a memoria dinámica? • El objeto cont2 al ser de la misma clase que cont1 igualmente ya cuenta con espacio en memoria dinámica, luego solo basta con copiar el nuevo valor respectivo en dicho espacio. • Qué pasa con los datos originales almacenados por cont2? Informática II 2011/2

42. Sobrecargando el operador = //sobrecarga el operador = constcontador& operator =(constcontador& other); //definiciondeloperador = constcontador& contador::operator =(constcontador& other){ if(this==&other){ return *this; } else{ variable=other.variable; } return *this; } Informática II 2011/2

43. GRACIAS POR SU ATENCIÓN Informática II 2011/2

44. Bibliografía • Curso C++ con clase http://c.conclase.net/curso/?cap=043 • Pagina de Referencia lenguaje C++: • http://www.cplusplus.com/reference/std/exception/exception/ • http://www.cplusplus.com/reference/std/stdexcept/ • Sams Teach yourselft C++ in 21 days: http://newdata.box.sk/bx/c/htm/ch20.htm#Heading1 Informática II 2011/2

45. Gracias ! Informática II 2011/2