C++ Academy · Lección

try, catch, throw

Gestione errores con excepciones

try, catch, throw es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

Señalar errores con throw

La instrucción throw lanza una excepción, abandona el flujo actual y busca un controlador en la pila de llamadas.

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::runtime_error("boom");
    } catch (const std::exception& e) {
        std::cout << e.what() << "\n";
    }
}

try y catch

El código que podría lanzar una excepción se coloca en un bloque try; los controladores correspondientes se escriben después en bloques catch.

#include <iostream>
#include <stdexcept>

int divide(int a, int b) {
    if (b == 0) throw std::invalid_argument("divide by zero");
    return a / b;
}

int main() {
    try {
        std::cout << divide(10, 0) << "\n";
    } catch (const std::invalid_argument& e) {
        std::cout << "error: " << e.what() << "\n";
    }
}

Capturar por referencia const

Capture siempre las excepciones mediante const&. Capturarlas por valor provoca el recorte de las excepciones derivadas y realiza copias innecesarias.

Múltiples bloques catch

Enumere los controladores desde el más específico hasta el más general. Se ejecutará el primer bloque que coincida.

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::out_of_range("bad index");
    } catch (const std::out_of_range& e) {
        std::cout << "range: " << e.what() << "\n";
    } catch (const std::exception& e) {
        std::cout << "other: " << e.what() << "\n";
    }
}

Desenrollado de la pila

Cuando se lanza una excepción, la pila se desenrolla: todos los objetos locales entre el lanzamiento y el controlador se destruyen en orden inverso.

#include <iostream>
#include <stdexcept>

struct Trace {
    ~Trace() { std::cout << "unwound\n"; }
};

void f() {
    Trace t;
    throw std::runtime_error("x");
}

int main() {
    try { f(); } catch (...) { std::cout << "caught\n"; }
}

Controlador general

Un bloque catch (...) captura cualquier tipo de excepción. Úselo con moderación, normalmente para registrar el error y volver a lanzar la excepción.

Volver a lanzar una excepción

Dentro de un controlador, un throw; sin argumento vuelve a lanzar la excepción actual y conserva su tipo, para que un controlador externo pueda gestionarla.

#include <iostream>
#include <stdexcept>

void inner() { throw std::runtime_error("deep"); }

void middle() {
    try { inner(); }
    catch (...) { std::cout << "logged\n"; throw; }   // rethrow
}

int main() {
    try { middle(); } catch (const std::exception& e) { std::cout << e.what() << "\n"; }
}

Jerarquía de excepciones estándar

La mayoría de las excepciones estándar derivan de std::exception, que expone what(). Capturar std::exception permite gestionar todas ellas.

Lanzar por valor, capturar por referencia

Lance los objetos de excepción temporales por valor; el entorno de ejecución los copia en un área segura. Captúrelos por referencia para evitar el recorte.

Excepciones frente a códigos de error

Las excepciones separan la ruta de error de la ruta normal y no pueden ignorarse silenciosamente, a diferencia de los códigos de retorno. Resérvelas para situaciones realmente excepcionales.

Las excepciones no capturadas terminan el programa

Si ningún controlador coincide, se llama a std::terminate y el programa se aborta. Gestione siempre las excepciones que espere.

Comprobación rápida

Compruebe su comprensión del manejo de excepciones.

Resumen

Ha aprendido a señalar errores con throw, gestionarlos con try/catch y cómo el desenrollado de la pila destruye los objetos locales durante el proceso. Capture mediante const&, ordene los controladores de los más específicos a los más generales y vuelva a lanzar la excepción con un throw; sin argumento.

Preguntas frecuentes

¿La lección «try, catch, throw» es gratis?

Sí — el texto completo de «try, catch, throw» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «try, catch, throw»?

Gestione errores con excepciones Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «try, catch, throw»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy