HOWTO · C++
Crie um arquivo em C++
Este artigo demonstra como criar um arquivo em C++
Nesta página
Para criar um arquivo em C++, abra-o para gravação. Para gravações comuns em C++, std::ofstream é a opção mais simples: cria um arquivo inexistente e, por padrão, substitui o conteúdo de um arquivo existente. Use std::fstream quando precisar realizar operações de leitura e gravação no mesmo fluxo, ou fopen quando estiver usando a interface de E/S padrão da linguagem C. Escolha o modo conforme queira manter, substituir ou acrescentar conteúdo ao arquivo.
Crie ou sobrescreva um arquivo com std::ofstream
std::ofstream é um fluxo de saída para arquivos. Construí-lo com um caminho abre o arquivo; chamar depois sua função membro open faz o mesmo. O modo padrão inclui std::ios_base::out, que cria o arquivo se necessário e trunca um arquivo existente. Verifique o fluxo antes de gravar para detectar problemas com o caminho ou com as permissões. O exemplo independente a seguir grava uma linha e depois lê o arquivo para mostrar seu conteúdo. O código e os rótulos ou saídas exibidos no exemplo permanecem em inglês:
#include <fstream>
#include <iostream>
int main() {
const char* path = "output.txt";
{
std::ofstream file(path);
if (!file) {
std::cout << "Could not open file\n";
return 1;
}
file << "First line\n";
}
std::ifstream input(path);
if (!input) {
std::cout << "Could not read file\n";
return 1;
}
std::cout << input.rdbuf();
return 0;
}
O fluxo de saída é fechado quando seu escopo termina, concluindo a gravação antes de o fluxo de entrada ler o arquivo. Este exemplo sobrescreve output.txt a cada execução. Ele não cria diretórios-pai inexistentes; portanto, o diretório-pai do caminho escolhido já precisa existir.
Crie ou acrescente conteúdo a um arquivo com std::fstream
Use std::fstream quando um fluxo precisar realizar operações de leitura e gravação. Adicione std::ios_base::app para gravar no final do arquivo. Esse modo cria o arquivo se ele não existir, e cada gravação vai para o final, preservando o conteúdo anterior. Neste exemplo, uma gravação inicial curta fornece conteúdo que a operação de anexação mantém. O código e os rótulos ou saídas exibidos no exemplo permanecem em inglês:
#include <fstream>
#include <iostream>
int main() {
const char* path = "output.txt";
{
std::ofstream seed(path);
if (!seed) {
std::cout << "Could not open file\n";
return 1;
}
seed << "Start\n";
}
{
std::fstream file;
file.open(path, std::ios_base::app);
if (!file.is_open()) {
std::cout << "Could not append to file\n";
return 1;
}
file << "Added\n";
}
std::ifstream input(path);
if (!input) {
std::cout << "Could not read file\n";
return 1;
}
std::cout << input.rdbuf();
return 0;
}
open é uma função membro de std::fstream; não é uma função integrada nem uma API std::open. A função membro is_open() do fluxo informa se ele está associado a um arquivo. Verificá-la antes de gravar evita que o programa trate uma falha ao abrir o arquivo como uma anexação bem-sucedida.
Crie ou abra um arquivo com fopen
A função de E/S padrão da linguagem C fopen recebe um caminho e uma string de modo e retorna um FILE*. Um ponteiro nulo indica que não foi possível abrir o arquivo; por isso, verifique o resultado antes de chamar fwrite ou realizar outra operação com ele. Por exemplo, o modo w cria um arquivo inexistente e trunca um arquivo existente. O programa a seguir grava uma linha, verifica os resultados da gravação e do fechamento, depois lê o arquivo e exibe seu conteúdo. O código e os rótulos ou saídas exibidos no exemplo permanecem em inglês:
#include <cstdio>
#include <iostream>
int main() {
const char* path = "output.txt";
FILE* file = std::fopen(path, "w");
if (file == nullptr) {
std::cout << "Could not open file\n";
return 1;
}
const char text[] = "Created with fopen\n";
const std::size_t written = std::fwrite(text, 1, sizeof(text) - 1, file);
if (written != sizeof(text) - 1) {
std::cout << "Could not write complete file\n";
std::fclose(file);
return 1;
}
if (std::fclose(file) != 0) {
std::cout << "Could not close file\n";
return 1;
}
FILE* input = std::fopen(path, "r");
if (input == nullptr) {
std::cout << "Could not read file\n";
return 1;
}
char buffer[128];
while (std::fgets(buffer, sizeof(buffer), input) != nullptr) {
std::cout << buffer;
}
if (std::ferror(input)) {
std::cout << "Could not read file\n";
std::fclose(input);
return 1;
}
if (std::fclose(input) != 0) {
std::cout << "Could not close input file\n";
return 1;
}
return 0;
}
O modo w+ também trunca o arquivo, mas permite leitura e gravação. O modo a cria o arquivo se ele não existir e acrescenta as gravações ao final; a+ também permite leitura. Em contrapartida, r e r+ exigem que o arquivo já exista. Ao terminar, chame fclose para liberar o fluxo da linguagem C e detectar uma eventual falha ao fechá-lo.
Escolha um modo e verifique o resultado
Escolha o modo de saída conforme o que deve acontecer com o conteúdo existente. O modo padrão de std::ofstream usa std::ios_base::out e substitui os dados existentes. Use std::ios_base::app quando todas as gravações precisarem ir para o final. Na E/S padrão da linguagem C, w substitui o conteúdo e a o acrescenta. Esses modos de gravação criam o arquivo se o diretório-pai existir e permitir gravações; eles não criam diretórios.
Para fluxos de C++, teste o fluxo com if (!file) depois de abri-lo ou use is_open() para verificar se está associado a um arquivo. Para fopen, compare o ponteiro retornado com nullptr. Verificar a abertura confirma que ela foi bem-sucedida, mas não garante que todas as gravações ou o fechamento também terão sucesso; verifique os resultados dessas operações quando essas falhas forem relevantes. Consulte a referência dos modos de abertura de C++ para ver as combinações de modos dos fluxos e obter mais detalhes.