Escrita de arquivos com ofstream
Escreva arquivos de saída
Escrita de arquivos com ofstream é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.
O que é ofstream?
std::ofstream (fluxo de arquivo de saída) escreve dados em arquivos. Ele funciona como std::cout, mas seu destino é um arquivo.
#include <iostream>
#include <fstream>
int main() {
std::ofstream out("hello.txt");
out << "Hello, file!\n";
std::cout << "wrote file\n";
return 0;
}Escrevendo texto
Use o operador << para escrever strings e números, exatamente como ao exibir conteúdo no console.
#include <iostream>
#include <fstream>
int main() {
std::ofstream out("report.txt");
out << "Score: " << 95 << '\n';
out << "Grade: A\n";
std::cout << "done\n";
return 0;
}Truncamento por padrão
Abrir um arquivo existente com ofstream apaga seu conteúdo anterior. Cada execução começa com o arquivo vazio.
#include <iostream>
#include <fstream>
int main() {
std::ofstream("t.txt") << "old content\n";
std::ofstream out("t.txt");
out << "new content\n";
std::ifstream in("t.txt");
std::string line; std::getline(in, line);
std::cout << line << '\n';
return 0;
}Anexando com o modo app
Passe std::ios::app para manter o conteúdo existente e adicionar novos dados ao final.
#include <iostream>
#include <fstream>
int main() {
std::ofstream("log.txt") << "line1\n";
std::ofstream out("log.txt", std::ios::app);
out << "line2\n";
out.close();
std::ifstream in("log.txt");
std::string l; int n = 0;
while (std::getline(in, l)) ++n;
std::cout << n << " lines\n";
return 0;
}Verificando se a escrita foi bem-sucedida
Teste o fluxo depois de abri-lo. Se ele estiver em um estado bad, a escrita falhará silenciosamente.
#include <iostream>
#include <fstream>
int main() {
std::ofstream out("ok.txt");
if (!out) {
std::cout << "failed to open\n";
return 1;
}
out << "safe write\n";
std::cout << "write ok\n";
return 0;
}Escrevendo números e formatando
Manipuladores de E/S, como std::fixed e std::setprecision, também se aplicam aos fluxos de arquivo.
#include <iostream>
#include <fstream>
#include <iomanip>
int main() {
std::ofstream out("pi.txt");
out << std::fixed << std::setprecision(3) << 3.14159 << '\n';
out.close();
std::ifstream in("pi.txt");
std::string s; in >> s;
std::cout << s << '\n';
return 0;
}Escrevendo dados em um laço
Escreva várias linhas usando um laço. Cada iteração envia um registro ao arquivo.
#include <iostream>
#include <fstream>
int main() {
std::ofstream out("squares.txt");
for (int i = 1; i <= 5; ++i) out << i << ' ' << i * i << '\n';
out.close();
std::cout << "wrote 5 rows\n";
return 0;
}Esvaziando o buffer
A saída é armazenada em buffer. std::flush ou std::endl força o envio imediato do buffer ao disco; fechar o arquivo também o esvazia.
#include <iostream>
#include <fstream>
int main() {
std::ofstream out("flush.txt");
out << "important" << std::flush;
std::cout << "flushed to disk\n";
return 0;
}endl versus quebra de linha
'\n' apenas adiciona uma quebra de linha. std::endl adiciona uma quebra de linha e esvazia o buffer, o que é mais lento em laços apertados.
#include <iostream>
#include <fstream>
int main() {
std::ofstream out("nl.txt");
out << "fast\n"; // newline only
out << "slow" << std::endl; // newline + flush
std::cout << "both written\n";
return 0;
}Escrever e depois ler
Um padrão comum é: escrever os dados, fechar o arquivo e depois reabri-lo para lê-los.
#include <iostream>
#include <fstream>
int main() {
{
std::ofstream out("rt.txt");
out << 7 << ' ' << 8 << '\n';
}
std::ifstream in("rt.txt");
int a, b; in >> a >> b;
std::cout << a + b << '\n';
return 0;
}Escolhendo modos de abertura
Combine as sinalizações com |. Modos comuns: ios::out (padrão), ios::app (anexar), ios::trunc (apagar).
#include <iostream>
#include <fstream>
int main() {
std::ofstream out("modes.txt", std::ios::out | std::ios::trunc);
out << "fresh\n";
std::cout << "opened with explicit modes\n";
return 0;
}Verificação rápida
Teste sua compreensão sobre os modos de ofstream.
Recapitulação
Você aprendeu que std::ofstream:
- escreve com
<<, fazendo o truncamento por padrão - anexa dados com
std::ios::app - armazena a saída em buffer;
std::flush/std::endl/o fechamento a enviam ao disco
Em seguida, você lidará com bytes brutos usando E/S de arquivos binários.
Perguntas Frequentes
A aula “Escrita de arquivos com ofstream” é grátis?
Sim — o texto completo de “Escrita de arquivos com ofstream” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.
O que vou aprender em “Escrita de arquivos com ofstream”?
Escreva arquivos de saída Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C++ Academy?
Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Escrita de arquivos com ofstream”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C++ Academy?
Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Leitura de arquivos com ifstream
- Escrita de arquivos com ofstream
- E/S de arquivos binários
- Tratamento de erros e estado