Ficheiros e validação

As notas podem ficar num ficheiro de texto para serem lidas noutra execução. Usamos uma linha por registo, com um nome sem espaços e uma nota inteira de 0 a 20.

Admite espaços antes, entre e depois dos campos. A biblioteca extrai os valores. O programa confirma o formato completo e o intervalo.

Abrir, escrever e fechar

std::ifstream abre para leitura e std::ofstream para escrita. Por defeito, ofstream substitui o conteúdo de um ficheiro existente. Usa std::ios::app quando o contrato é acrescentar ao fim. O caminho relativo é resolvido a partir da pasta de trabalho do processo, não da pasta onde está o código.

Programa completo para compilar localmente:

#include <fstream>
#include <iostream>
#include <string>

int main() {
    {
        std::ofstream saida("notas.txt");
        if (!saida) { std::cout << "Erro de abertura\n"; return 0; }
        saida << "Ana 15\nRui 12\n";
        saida.close();
        if (!saida) { std::cout << "Erro de escrita\n"; return 0; }
    }
    std::ifstream entrada("notas.txt");
    if (!entrada) { std::cout << "Erro de leitura\n"; return 0; }
    std::string nome;
    int nota = 0;
    int total = 0;
    while (entrada >> nome >> nota) {
        std::cout << nome << ": " << nota << "\n";
        total += nota;
    }
    if (entrada.bad()) { std::cout << "Erro de I/O\n"; return 0; }
    std::cout << "Total: " << total << "\n";
}

Saída:

Ana: 15
Rui: 12
Total: 27

O programa cria notas.txt na pasta de trabalho e corre localmente, porque o executor do navegador não cria ficheiros; fecha a escrita antes de leres e verifica close(), pois o destrutor fecha mas não trata um erro final de escrita.

A leitura por tokens acima serve um ficheiro conhecido; para dados externos, ler por linhas distingue um registo incompleto do fim normal, validando cada linha em três passos: ler nome e nota, confirmar que não sobra texto e confirmar o intervalo.

Ler sem antecipar o fim

O ciclo while (entrada >> nome >> nota) só entra no corpo depois de ler os dois campos. eof() indica que uma operação anterior encontrou o fim; não prevê se a próxima leitura vai resultar.

Por isso while (!entrada.eof()) pode repetir o último registo ou usar dados incompletos.

Os fluxos conservam estado. fail() sinaliza falha de uma operação ou conversão. bad() sinaliza uma falha grave de I/O. eof() indica encontro do fim. Estes estados podem coexistir.

Depois de uma falha, novas leituras não prosseguem normalmente até limpar o estado com clear() e tratar a entrada problemática. Limpar o estado sem consumir ou corrigir a causa pode criar um ciclo sem progresso.

Separar linhas e registos

A leitura por tokens ignora espaços e fins de linha. Se o formato exige exatamente um registo por linha, lê primeiro a linha e interpreta-a num istringstream. Esta classe permite tratar uma string como um fluxo, sem abrir outro ficheiro.

#include <iostream>
#include <sstream>
#include <string>

int main() {
    std::string linha;
    int numero = 0;
    while (std::getline(std::cin, linha)) {
        ++numero;
        std::istringstream registo(linha);
        std::string nome;
        std::string extra;
        int nota = 0;
        bool leu = static_cast<bool>(registo >> nome >> nota);
        bool sobra = static_cast<bool>(registo >> extra);
        bool intervalo = (nota >= 0 && nota <= 20);
        if (!leu || sobra || !intervalo) {
            std::cout << "Linha " << numero << " invalida\n";
            continue;
        }
        std::cout << nome << ": " << nota << "\n";
    }
}

Saída:

Ana: 15
Linha 2 invalida
Linha 3 invalida
Rui: 20

No exemplo, Ana 15 lê nome e 15, sem sobra e dentro do intervalo: válida; Eva 21 lê nome e 21, sem sobra, mas fora do intervalo: inválida; Leo 12 lixo lê 12 e ainda encontra lixo: inválida; Eva 12abc lê 12 e deixa abc por consumir: inválida. Uma linha vazia falha logo na primeira leitura.

Cada iteração cria um fluxo novo para a linha, por isso uma falha de conversão não contamina a seguinte. Se o formato permitisse nomes com espaços, teria de usar outra separação, por exemplo um delimitador, e definir como esse delimitador pode aparecer nos campos. Depois de uma falha de conversão no fluxo principal, limpa o estado e consome a entrada problemática antes de continuar:

// Excerto: recupera de uma leitura falhada.
#include <limits>
entrada.clear();
entrada.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

Binário não é memória bruta portátil

std::ios::binary evita transformações de texto próprias da plataforma. Não define por si só um formato de dados. Escrever os bytes de uma struct depende do padding, da ordem dos bytes e da representação dos tipos. Um formato portátil especifica tamanhos, ordem dos bytes e codificação, ou usa uma biblioteca que trate essas decisões.

Caso resolvido: fim depois de um nome

Com a linha Ana, sem nota, getline resulta porque leu uma linha, mas a extração do nome resulta e a da nota falha. Por isso leu é falso e o programa rejeita o registo sem usar o valor anterior de nota.

Num ficheiro vazio, getline falha antes do corpo do ciclo e não existe registo a validar. Os dois casos chegam ao fim dos dados com significados diferentes:

• registo incompleto: existe uma linha, mas falta um campo ou o formato é inválido;
• ausência de registo: não existe linha nenhuma para validar.

Só o primeiro caso produz uma mensagem de linha inválida.