Programación Orientada a Objetos - Unidad 5 Excepciones

TECNOLÓGICO NACIONAL DE MÉXICO
Instituto Tecnológico Superior de Guasave
Ingeniería en Sistemas Computacionales
Programación Orientada a Objetos
Unidad 5: Excepciones
PROGRAMACIÓN ORIENTADA A OBJETOS

Competencia de la unidad:
Comprende y aplica la clasificación de archivos y operaciones
básicas sobre éstos para manipular su información.

¿Qué son las Excepciones?
• Ocasionalmente es posible que ciertas instrucciones no funcionen
adecuadamente o se encuentren con problemas de ejecución no
contemplados. C++ proporciona un mecanismo para manejar este tipo
de situaciones o errores en tiempo de ejecución llamado Excepciones.
• El mecanismo de excepciones está basado en las palabras clave: try,
catch y throw.

• La forma en que trabaja éste mecanismo es que cuando ocurre un
evento o error inesperado C++ busca un segmento de código neutral,
esto es, la sección final del mecanismo, el bloque catch.
• Si todo salió bien y no se presentaron errores, únicamente se ejecutará
el código del bloque try, por lo tanto en éste caso el bloque catch es
completamente ignorado.

• Es importante señalar que los únicos errores que se pueden controlar
son los producidos en tiempo de ejecución dentro del propio programa,
conocidos como errores síncronos.
• Es imposible controlar errores debido al mal funcionamiento del sistema
por cortes eléctricos, bloqueos de la computadora, etc.

• Podemos decir que el programa se prepara para cierta acción, decimos
que "lo intenta". Para ello se especifica un bloque de código cuya
ejecución se va a intentar ("try‐block") utilizando la palabra clave try:

• Un ejemplo sencillo sería la operación en la que se dividen dos
números, no puede realizarse una división entre cero por lo que C++
regresa un error crítico que provoca el cierre de la aplicación en caso de
no ser controlado por medio de una excepción.

El bloque catch
• Mediante la palabra clave catch especificamos el código encargado de
reaccionar ante una determinada excepción o conjunto de excepciones.
• En C++ es obligatorio que tras un bloque try se incluya al menos un
bloque catch, por lo que la sintaxis anterior quedaría completa de la
siguiente forma:

Lanzamiento de una excepción throw()
• Las excepciones no sólo las lanzan las funciones incluidas dentro de las
librerías externas, sino que nosotros podemos querer informar que algo
no ha ido bien dentro de la lógica de nuestro programa, esto se realiza
por medio de la instrucción throw().

El sistema tiene un número de excepciones predefinidas, que pueden, a su
vez, ser base para nuevas excepciones definidas por el programador.
• logic_error(str): son, en teoría, predecibles y por lo tanto evitables
mediante chequeos adecuados insertados en lugares estratégicos.
(#include <stdexcept>)
 domain_error(str)
 invalid_argument(str)
 length_error(str)
 out_of_range(str)

• runtime_error(str): son errores impredecibles y la única alternativa es
su manejo en tiempo de ejecución. (#include <stdexcept>)
 range_error(str)
 overflow_error(str)
 underflow_error(str)
• bad_alloc(): lanzada en fallo en new (#include <new>)
• bad_cast(): lanzada en fallo en dynamic_cast (#include <typeinfo>)
• bad_typeid(): lanzada en fallo en typeid (#include <typeinfo>)
• bad_exception(): lanzada en fallo en la especificacion de excepciones
lanzadas por una función. (#include <exception>)

Excepciones definidas por el lenguaje
• Como ya lo vimos en diapositivas anteriores es posible utilizar las
excepciones que el propio lenguaje C++ proporciona para ciertos
aspectos, como verificar si se produce un error al asignar memoria a un
vector, etc.

• Ejemplo: vemos el ejemplo de como validar por medio de excepciones un
programa crea arreglos y les asigna memoria, en este caso utilizamos
punteros debido a que los arreglos se crean de forma dinámica por lo que
se debe asignar un espacio de memoria para cada uno.
• Definición de puntero: Un puntero es una variable que contiene la
dirección de memoria de un dato o de otra variable que contiene al dato en
un arreglo.

#include <iostream>
#include <exception>
using namespace std;
class arreglos {
public:
double *ptr[50];
arreglos();
void dinamico();
};
arreglos::arreglos() { }
void arreglos::dinamico() {
try {
for (int i= 0 ; i < 50; i++) {
// asignación dinámica de memoria
ptr[i] = new double[50000000];
cout << "Reservando memoria "
<< i << endl;
}
} catch (bad_alloc ex){
cout << "Error: " << ex.what() << endl;
}
}
int main()
{
arreglos arr;
arr.dinamico();
return 0;
}
Ejemplo:

Excepciones lanzadas por el usuario
Ejemplo de como lanzar excepciones: Se lanzará una excepción al momento de
capturar un numero menor o igual a cero.
try {
cout << “capture num: ”;
cin>>num;
fflush(stdin);
if (num <=0) throw invalid_argument(“Numero no valido”);
} catch (invalid_argument e) {
cout << “Error: ” << e.what();
}

• Otra forma de lanzar excepciones es disparándolas en una función
independiente, la cual se encarga de evaluar los argumentos necesarios
y determinar si hay o no que lanzar la excepción.
• struct: esta orden se emplea para agrupar variables de tipos
iguales o diferentes en un solo registro, con la misma se
pueden crear estructuras anónimas o estructuras con nombre;

Ejemplo de como lanzar una excepción por medio de un método auxiliar
//creamos una clase que contenga un struct
class valNum {
public:
struct NUM_NOVALIDO { };
valNum();
valNum(int x);
int num;
};
valNum::valNum(){ // contructor
num=0;
}
// metodo que lanza la excepción en caso de recibir un
// entero menor o igual a cero
valNum::validar(int x) {
if (num <= 0) {
throw NUM_NOVALIDO();
}
}
// capturamos un número entero y se llama la validación
int main() {
valNum v;
try {
cout<<"Número: ";
cin >> v.num;
fflush(stdin);
v.validar(v.num);
} catch ( ... ) {
// evalua cualquier tipo de excepcion recibida
cout << "Error inesperado" << endl;
}
cin.get();
}

Ejercicio:
• Realice un programa utilizando POO, debe capturar un número y
obtener su factorial.
• El factorial de un número (n!) es la multiplicación de los número que
van del 1 a dicho número.
• El programa debe validar desde una función independiente que no se
capturen números menores o iguales a cero, en caso de hacerlo debe
devolver una excepción y mostrar un error en pantalla.
• Debe incluir un menú que permita calcular un número indeterminado
de factoriales.

Práctica:
• Realice un programa utilizando POO, debe capturar dos números y
realice la división de ambos.
• Cuando un número es dividió entre cero C++ produce un error, en este
caso debes realizar la división en una función que regresa el resultado,
en caso de recibir un divisor cero debes lanzar una excepción y
regresarla al punto donde llamaste la función y mandar el mensaje a la
pantalla.

Proyecto para manejo de excepciones
• Utilizando POO desarrolle un programa que capture un número, y después
pregunte a que raíz se le desea convertir.
• Los números negativos reales tienen la propiedad de que no pueden ser
convertidos a raíces pares.
• Cuando un número negativo sea capturado y se intente convertir a una raíz
par debes lanzar una excepción e indicar en pantalla que no es posible
realizar el cálculo.
• Debes utilizar todos los recursos que C++ te proporciona para lograr validar
y lanzar la excepción.

Programación Orientada a Objetos - Unidad 5 Excepciones

Más contenido relacionado

La actualidad más candente (20)

Destacado (20)

Similar a Programación Orientada a Objetos - Unidad 5 Excepciones (20)

Más de José Antonio Sandoval Acosta (20)

Último (20)

Programación Orientada a Objetos - Unidad 5 Excepciones