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.