HOWTO · C++

Ler Ficheiro em Strings em C++

Este artigo demonstra como ler o ficheiro em string em C++

Nesta página

Para ler um ficheiro para uma std::string, use std::ifstream com std::getline quando quiser processar linha a linha, ou construa a string a partir de std::istreambuf_iterator<char> quando precisar de ler o fluxo completo. Os exemplos abaixo criam o seu próprio ficheiro temporário de entrada, pelo que cada programa pode ser compilado e executado de forma independente.

Utilizar std::ifstream e std::getline para ler um ficheiro para uma string em C++

std::getline remove o delimitador de cada linha. Acrescentar "\n" após cada chamada bem-sucedida repõe os separadores, mas também acrescenta uma quebra de linha depois da última linha, mesmo que o ficheiro de origem não termine com uma. Se essa diferença for importante, registe se havia um delimitador ou utilize um dos métodos abaixo para ler o fluxo completo.

Este exemplo completo escreve duas linhas num ficheiro temporário, abre-o com std::ifstream e acrescenta cada linha a uma string. O texto antes do exemplo descreve o funcionamento normal quando a operação é bem-sucedida.

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

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-lines.txt";
    {
        std::ofstream sample(path);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    std::ifstream inputFile(path);
    if (!inputFile) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    std::string fileContent;
    std::string line;
    while (std::getline(inputFile, line)) {
        fileContent += line + "\n";
    }
    if (inputFile.bad()) {
        std::cout << "Read failed\n";
        inputFile.close();
        std::filesystem::remove(path);
        return 0;
    }

    std::cout << fileContent;
    inputFile.close();
    std::filesystem::remove(path);
}

O ciclo termina quando std::getline já não consegue extrair uma linha. Verificar bad() permite distinguir uma falha de E/S de baixo nível do fim normal do fluxo. Por predefinição, o ficheiro é aberto em modo de texto; em sistemas que convertem os finais de linha, os bytes da string resultante podem diferir dos que estão guardados no ficheiro. Use o modo binário quando for necessário preservar os bytes exatamente.

Utilizar istreambuf_iterator para ler um ficheiro para uma string em C++

Para ler o fluxo completo, construa uma string a partir de um par de valores std::istreambuf_iterator<char>. O primeiro iterador lê do buffer do fluxo e o iterador construído por omissão assinala o fim. Este método lê os dados sem os dividir em linhas, preservando assim os caracteres de quebra de linha recebidos do fluxo.

#include <filesystem>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-iterator.txt";
    {
        std::ofstream sample(path, std::ios::binary);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    std::ifstream inputFile(path, std::ios::binary);
    if (!inputFile) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    const std::string fileContent{
        std::istreambuf_iterator<char>(inputFile),
        std::istreambuf_iterator<char>()};
    if (inputFile.bad()) {
        std::cout << "Read failed\n";
    } else {
        std::cout << fileContent << '\n';
    }
    inputFile.close();
    std::filesystem::remove(path);
}
alpha
beta

Use esta forma quando o ficheiro completo couber na memória e não for necessário processá-lo linha a linha. Abrir o ficheiro em modo binário evita a conversão de quebras de linha do modo de texto. Uma std::string pode conter bytes nulos, mas as funções que tratam c_str() como uma string de texto terminada em nulo podem parar no primeiro deles.

Utilizar rdbuf para ler um ficheiro para uma string em C++

Outra opção da biblioteca padrão consiste em inserir o rdbuf() do fluxo de entrada numa std::ostringstream e, em seguida, chamar str() para obter o conteúdo como uma std::string. Esta opção é conveniente quando o fluxo de string já faz parte do código envolvente. Verifique o fluxo de entrada após a transferência se precisar de detetar falhas de leitura.

#include <filesystem>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-rdbuf.txt";
    {
        std::ofstream sample(path, std::ios::binary);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    std::ifstream inputFile(path, std::ios::binary);
    if (!inputFile) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    std::ostringstream stream;
    stream << inputFile.rdbuf();
    if (inputFile.bad()) {
        std::cout << "Read failed\n";
    } else {
        const std::string fileContent = stream.str();
        std::cout << fileContent << '\n';
    }
    inputFile.close();
    std::filesystem::remove(path);
}

A inserção copia os caracteres do buffer do ficheiro para o fluxo de string; str() devolve a string acumulada. Para construir diretamente uma string a partir do ficheiro completo, a abordagem com iteradores exige menos etapas. Em ambos os casos, continua a ser necessário verificar se o ficheiro foi aberto e se ocorreu algum erro de leitura.

Utilizar a função fread para ler um ficheiro para uma string

fread é uma função da biblioteca padrão de C que também pode ser utilizada em C++. É útil quando o código já utiliza fluxos FILE* ou precisa de uma API de C orientada a bytes. Não é intrinsecamente mais rápida do que as abordagens com fluxos de C++; o desempenho depende da carga de trabalho e da implementação.

Este exemplo utiliza fseek e ftell para determinar o tamanho de um ficheiro de exemplo que permite posicionamento, aloca uma string desse tamanho e lê os bytes para a string. Para fluxos que não permitem posicionamento ou ficheiros demasiado grandes para a memória, leia blocos de tamanho fixo. O tamanho do ficheiro pode mudar entre a medição e a leitura, pelo que continua a ser necessário verificar o número de bytes devolvido e ferror.

#include <cstdio>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-fread.txt";
    {
        std::ofstream sample(path, std::ios::binary);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    std::FILE* file = std::fopen(path.string().c_str(), "rb");
    if (file == nullptr) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    if (std::fseek(file, 0, SEEK_END) != 0) {
        std::cout << "Could not seek sample file\n";
        std::fclose(file);
        std::filesystem::remove(path);
        return 0;
    }
    const long length = std::ftell(file);
    if (length < 0 || std::fseek(file, 0, SEEK_SET) != 0) {
        std::cout << "Could not determine sample size\n";
        std::fclose(file);
        std::filesystem::remove(path);
        return 0;
    }

    std::string content(static_cast<std::size_t>(length), '\0');
    const std::size_t bytesRead = std::fread(content.data(), 1, content.size(), file);
    const bool failed = std::ferror(file) != 0 || bytesRead != content.size();
    std::fclose(file);
    std::filesystem::remove(path);

    if (failed) {
        std::cout << "Read failed or file changed while reading\n";
        return 0;
    }
    std::cout << content << '\n';
}

O terceiro argumento indica o número de elementos e o segundo, o tamanho de cada elemento; usar 1 como tamanho do elemento faz com que o valor devolvido corresponda ao número de bytes. fread pode devolver menos bytes do que os pedidos, por isso não parta do princípio de que uma única chamada preenche o buffer. Este exemplo destina-se a um ficheiro que permite posicionamento e utiliza o intervalo long suportado por ftell; aplicações que precisem de trabalhar com ficheiros maiores devem recorrer a APIs para ficheiros grandes adequadas à plataforma ou ler em blocos. A string armazena bytes e não acrescenta um terminador nulo para funções que utilizam strings de C.

Utilizar read para ler um ficheiro para uma string

A função POSIX read trabalha com um descritor de ficheiro e um buffer fornecido pelo chamador. Não faz parte do C++ padrão; inclua os cabeçalhos POSIX adequados e utilize este método apenas em plataformas que disponibilizem essa API. Uma chamada bem-sucedida pode devolver menos bytes do que os pedidos, pelo que deve repetir as chamadas até ao fim do ficheiro e tratar interrupções e erros.

O programa POSIX abaixo lê os dados em blocos, sem depender de uma medição prévia do tamanho do ficheiro. As chamadas de sistema utilizadas não estão disponíveis em todas as plataformas C++, por isso considere-o um exemplo específico de POSIX, não de C++ portátil.

#include <cerrno>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>
#include <fcntl.h>
#include <unistd.h>

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-read.txt";
    {
        std::ofstream sample(path, std::ios::binary);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    const int fd = ::open(path.c_str(), O_RDONLY);
    if (fd < 0) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    std::string content;
    char buffer[4096];
    bool failed = false;
    for (;;) {
        const ssize_t count = ::read(fd, buffer, sizeof buffer);
        if (count > 0) {
            content.append(buffer, static_cast<std::size_t>(count));
        } else if (count == 0) {
            break;
        } else if (errno != EINTR) {
            failed = true;
            break;
        }
    }
    if (::close(fd) != 0) {
        failed = true;
    }
    std::filesystem::remove(path);

    if (failed) {
        std::cout << "Read or close failed\n";
        return 0;
    }
    std::cout << content << '\n';
}

Num ficheiro regular, read devolve zero quando chega ao fim. Noutros tipos de descritor, o comportamento depende do dispositivo ou fluxo. Cada valor de retorno positivo indica o número de bytes a acrescentar; um valor negativo indica um erro e, quando ocorre EINTR, a chamada pode ser repetida. Feche sempre o descritor e tenha em conta as leituras parciais, em vez de assumir que uma única chamada preenche o buffer pedido. O exemplo utiliza std::string::append para preservar o número exato de bytes, incluindo eventuais bytes nulos.

Conclusão

Em C++ portátil, escolha std::istreambuf_iterator ou rdbuf() quando quiser converter o fluxo completo numa string, e use std::getline quando for útil processar linha a linha. Lembre-se de que a extração de linhas remove os delimitadores e que voltar a acrescentá-los pode alterar uma última linha sem quebra final. Use fread quando uma interface C FILE* se adequar ao código envolvente, e recorra a read de POSIX apenas quando a API de descritores específica da plataforma for apropriada. Para ficheiros grandes, considere processar os dados em blocos em vez de manter o ficheiro inteiro na memória e verifique tanto os resultados da abertura como os da leitura.