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.