C++ Academy · Aula

Tratamento de erros e estado

Verifique o estado do fluxo

Tratamento de erros e estado é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Bits de estado do fluxo

Todo fluxo acompanha sua condição usando sinalizações de estado:

goodbit: está tudo bem.
eofbit: o fim do arquivo foi alcançado.
failbit: ocorreu um erro lógico (formato inválido).
badbit: ocorreu um erro 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;
}

Testando um fluxo

Um fluxo é convertido para bool: ele é true quando pode ser usado. if (!in) detecta uma falha 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 sinalização tem um método de consulta: good(), eof(), fail() e 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;
}

Extração malsucedida

Quando >> não consegue analisar o tipo esperado, ele define failbit e deixa o destino inalterado.

#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;
}

Limpando o estado

Depois que uma sinalização de falha é definida, o fluxo permanece inutilizável até que você chame clear() para redefini-la.

#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;
}

Ignorando uma entrada inválida

Depois de clear(), use ignore() para descartar os caracteres problemáticos antes de tentar novamente.

#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;
}

Distinguindo EOF de um erro

Depois que um laço de leitura termina, verifique se ele terminou corretamente com eof() ou se houve uma falha real com 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;
}

Verificando depois de abrir

Sempre verifique o fluxo logo depois de abrir um arquivo, para falhar rapidamente quando o caminho estiver ausente ou não puder ser lido.

#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;
}

Ativando exceptions

Você pode pedir ao fluxo que lance exceções em caso de erros com exceptions(), transformando falhas silenciosas em std::ios_base::failure que podem ser capturadas.

#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;
}

Validando a quantidade lida

Depois de um read binário, gcount() informa quantos bytes foram realmente lidos, permitindo detectar leituras 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;
}

Um laço de leitura robusto

Combine as técnicas: teste o fluxo dentro do laço e, depois que ele terminar, distinga uma conclusão normal de um erro.

#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;
}

Verificação rápida

Teste sua compreensão sobre o estado do fluxo.

Recapitulação

Você aprendeu a lidar com erros do fluxo:

as sinalizações de estado good/eof/fail/bad, consultadas por meio de seus métodos ou testando o fluxo como um bool
clear() redefine o estado e ignore() descarta a entrada inválida
distinga um eof() normal de erros reais; exceptions() pode lançar exceções, e gcount() valida leituras binárias

Próximo curso: gerando números aleatórios com <random>.

Perguntas Frequentes

A aula “Tratamento de erros e estado” é grátis?

Sim — o texto completo de “Tratamento de erros e estado” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Tratamento de erros e estado”?

Verifique o estado do fluxo Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Tratamento de erros e estado”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy