El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Manejo de Excepciones

Siguiente ►
►

El manejo de excepciones es una característica fundamental en C++ que permite a los programadores gestionar errores y condiciones excepcionales de manera controlada. En este módulo, aprenderemos cómo utilizar las excepciones para mejorar la robustez y la fiabilidad de nuestros programas.

Conceptos Clave

  1. Excepción: Un evento que ocurre durante la ejecución de un programa y que interrumpe el flujo normal de las instrucciones.
  2. Lanzar (throw): La acción de generar una excepción.
  3. Capturar (catch): La acción de manejar una excepción lanzada.
  4. Bloque try: Un bloque de código que contiene instrucciones que pueden lanzar excepciones.
  5. Bloque catch: Un bloque de código que maneja las excepciones lanzadas en el bloque try.

Estructura Básica del Manejo de Excepciones

La estructura básica para el manejo de excepciones en C++ incluye los bloques try, throw y catch. A continuación se muestra un ejemplo simple:

#include <iostream>
using namespace std;

int main() {
    try {
        // Bloque de código que puede lanzar una excepción
        int divisor = 0;
        if (divisor == 0) {
            throw "División por cero no permitida";
        }
        int result = 10 / divisor;
        cout << "Resultado: " << result << endl;
    } catch (const char* e) {
        // Bloque de código que maneja la excepción
        cout << "Error: " << e << endl;
    }
    return 0;
}

Explicación del Código

  1. Bloque try: Contiene el código que puede lanzar una excepción. En este caso, estamos verificando si el divisor es cero antes de realizar una división.
  2. throw: Si el divisor es cero, lanzamos una excepción con el mensaje "División por cero no permitida".
  3. Bloque catch: Captura la excepción lanzada y maneja el error imprimiendo un mensaje.

Tipos de Excepciones

En C++, se pueden lanzar y capturar diferentes tipos de excepciones, incluyendo tipos básicos como int, char, double, y tipos definidos por el usuario como clases y estructuras.

Ejemplo con Diferentes Tipos de Excepciones

#include <iostream>
using namespace std;

void checkNumber(int num) {
    if (num < 0) {
        throw num; // Lanza una excepción de tipo int
    } else if (num == 0) {
        throw "Número es cero"; // Lanza una excepción de tipo const char*
    } else if (num > 100) {
        throw 1.0; // Lanza una excepción de tipo double
    }
}

int main() {
    try {
        checkNumber(150);
    } catch (int e) {
        cout << "Error: Número negativo " << e << endl;
    } catch (const char* e) {
        cout << "Error: " << e << endl;
    } catch (double e) {
        cout << "Error: Número mayor que 100" << endl;
    }
    return 0;
}

Explicación del Código

  1. checkNumber: Función que lanza diferentes tipos de excepciones basadas en el valor del argumento num.
  2. Bloques catch: Capturan y manejan las excepciones de diferentes tipos (int, const char*, double).

Ejercicio Práctico

Ejercicio 1: Manejo de Excepciones en una Calculadora

Escribe un programa que implemente una calculadora simple que maneje excepciones para las siguientes operaciones: suma, resta, multiplicación y división. El programa debe lanzar una excepción si se intenta dividir por cero.

Solución

#include <iostream>
using namespace std;

double calculate(double a, double b, char op) {
    switch (op) {
        case '+':
            return a + b;
        case '-':
            return a - b;
        case '*':
            return a * b;
        case '/':
            if (b == 0) {
                throw "División por cero no permitida";
            }
            return a / b;
        default:
            throw "Operador no válido";
    }
}

int main() {
    double num1, num2;
    char op;
    cout << "Ingrese dos números y un operador (+, -, *, /): ";
    cin >> num1 >> num2 >> op;

    try {
        double result = calculate(num1, num2, op);
        cout << "Resultado: " << result << endl;
    } catch (const char* e) {
        cout << "Error: " << e << endl;
    }

    return 0;
}

Explicación del Código

  1. calculate: Función que realiza la operación aritmética basada en el operador proporcionado. Lanza excepciones si se intenta dividir por cero o si se proporciona un operador no válido.
  2. Bloque try: Llama a la función calculate y maneja cualquier excepción lanzada.
  3. Bloque catch: Captura y maneja las excepciones lanzadas por la función calculate.

Resumen

En esta sección, hemos aprendido los conceptos básicos del manejo de excepciones en C++, incluyendo cómo lanzar y capturar excepciones utilizando los bloques try, throw y catch. También hemos visto ejemplos prácticos y un ejercicio para reforzar los conceptos aprendidos. El manejo adecuado de excepciones es crucial para escribir programas robustos y fiables, y es una habilidad esencial para cualquier programador de C++.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados