0Pricing
C++ Academy · Lección

Gestión de errores y estado

Compruebe el estado del flujo

Gestión de errores y estado es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 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.

Bits de estado del flujo

Cada flujo realiza un seguimiento de su estado mediante indicadores:

  • goodbit: todo está bien.
  • eofbit: se alcanzó el final del archivo.
  • failbit: se produjo un error lógico (formato incorrecto).
  • badbit: se produjo un error grave de E/S.
#include <iostream>
#include <fstream>

int main() {
    std::ifstream in("missing_98765.txt");
    std::cout << std::boolalpha << "good: " << in.good() << '\n';
    return 0;
}

Probar un flujo

Un flujo se convierte a bool: es true cuando se puede utilizar. if (!in) detecta los fallos de forma concisa.

#include <iostream>
#include <fstream>

int main() {
    std::ifstream in("nope_55555.txt");
    if (!in) std::cout << "stream not usable\n";
    else std::cout << "ok\n";
    return 0;
}

good, eof, fail, bad

Cada indicador tiene un método de consulta: good(), eof(), fail() y bad().

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("abc");
    int x;
    s >> x; // fails: not a number
    std::cout << std::boolalpha;
    std::cout << "fail: " << s.fail() << '\n';
    std::cout << "bad: " << s.bad() << '\n';
    return 0;
}

Extracción fallida

Cuando >> no puede analizar el tipo esperado, establece failbit y deja el destino sin cambios.

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("hello");
    int n = -1;
    if (!(s >> n)) std::cout << "could not read an int, n stays " << n << '\n';
    return 0;
}

Borrar el estado

Una vez establecido un indicador de error, el flujo permanece inutilizable hasta que llama a clear() para restablecerlo.

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("x 42");
    int n;
    s >> n;          // fails on 'x'
    s.clear();       // reset state
    std::string word;
    s >> word;       // now reads 'x'
    std::cout << "recovered: " << word << '\n';
    return 0;
}

Ignorar entradas incorrectas

Después de llamar a clear(), use ignore() para descartar los caracteres problemáticos antes de volver a intentarlo.

#include <iostream>
#include <sstream>
#include <limits>

int main() {
    std::istringstream s("bad 100");
    int n;
    while (!(s >> n)) {
        s.clear();
        s.ignore(std::numeric_limits<std::streamsize>::max(), ' ');
    }
    std::cout << "read " << n << '\n';
    return 0;
}

Distinguir el final del archivo de un error

Cuando termina un bucle de lectura, compruebe si finalizó limpiamente con eof() o debido a un fallo real indicado por bad().

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("1 2 3");
    int x;
    while (s >> x) {}
    std::cout << std::boolalpha << "reached eof: " << s.eof() << '\n';
    std::cout << "hardware error: " << s.bad() << '\n';
    return 0;
}

Comprobar después de abrir

Verifique siempre el flujo inmediatamente después de abrir un archivo para detectar cuanto antes una ruta inexistente o no legible.

#include <iostream>
#include <fstream>

int main() {
    std::ifstream in("absent_11111.txt");
    if (!in.is_open()) {
        std::cout << "open failed, aborting\n";
        return 1;
    }
    std::cout << "never reached\n";
    return 0;
}

Activar excepciones

Puede pedirle a un flujo que lance excepciones cuando se produzcan errores mediante exceptions(), convirtiendo los fallos silenciosos en excepciones std::ios_base::failure que se pueden capturar.

#include <iostream>
#include <fstream>

int main() {
    std::ifstream in;
    in.exceptions(std::ios::failbit);
    try {
        in.open("ghost_22222.txt");
    } catch (const std::exception& e) {
        std::cout << "caught open failure\n";
    }
    return 0;
}

Validar la cantidad leída

Después de un read binario, gcount() indica cuántos bytes se leyeron realmente, lo que permite detectar lecturas incompletas.

#include <iostream>
#include <fstream>

int main() {
    int v = 9;
    std::ofstream("g.bin", std::ios::binary).write(reinterpret_cast<const char*>(&v), sizeof(v));
    int out;
    std::ifstream in("g.bin", std::ios::binary);
    in.read(reinterpret_cast<char*>(&out), sizeof(out));
    std::cout << "read " << in.gcount() << " bytes\n";
    return 0;
}

Un bucle de lectura robusto

Combine las técnicas: pruebe el flujo en la condición del bucle y, cuando termine, distinga una finalización limpia de un error.

#include <iostream>
#include <sstream>

int main() {
    std::istringstream s("5 10 15");
    int total = 0, x;
    while (s >> x) total += x;
    if (s.eof()) std::cout << "sum = " << total << " (clean)\n";
    else std::cout << "error during read\n";
    return 0;
}

Comprobación rápida

Compruebe su comprensión del estado del flujo.

Resumen

Ha aprendido a gestionar errores de los flujos:

  • los indicadores de estado good/eof/fail/bad se consultan mediante sus métodos o probando el flujo como un bool
  • clear() restablece el estado y ignore() descarta las entradas incorrectas
  • distinga un eof() limpio de los errores reales; exceptions() puede lanzar excepciones y gcount() valida las lecturas binarias

Siguiente curso: generar números aleatorios con <random>.

Preguntas frecuentes

¿La lección «Gestión de errores y estado» es gratis?

Sí — el texto completo de «Gestión de errores y estado» 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 «Gestión de errores y estado»?

Compruebe el estado del flujo 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 4 de 4.

¿Cuánto tiempo toma la lección «Gestión de errores y estado»?

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

  1. Lectura de archivos con ifstream
  2. Escritura de archivos con ofstream
  3. E/S de archivos binarios
  4. Gestión de errores y estado
← Volver a C++ Academy