Neste artigo, mostraremos como ler e gravar em um arquivo na linguagem de programação C ++ usando vários exemplos. Para entender as operações de arquivo C ++ como leitura e gravação, devemos primeiro entender o conceito de fluxo em C ++.
O que é um stream?
Um fluxo é simplesmente um fluxo de dados ou caracteres. Existem dois tipos de fluxos: fluxos de entrada e fluxos de saída. Um fluxo de entrada é usado para ler os dados de um dispositivo de entrada externo, como um teclado, enquanto um fluxo de saída é usado para gravar dados no dispositivo de saída externo, como um monitor. Um arquivo pode ser considerado uma fonte de entrada e saída.
Em C ++, usamos um fluxo para enviar ou receber dados de ou para uma fonte externa.
Podemos usar classes integradas para acessar um fluxo de entrada / saída, ou seja, ios.
Aqui está a hierarquia de classes de fluxo da linguagem de programação C ++:
Os objetos cin e cout são usados para ler os dados do teclado e para exibir a saída no monitor, respectivamente. Além disso, ifstream, que significa fluxo de arquivo de entrada, é usado para ler um fluxo de dados de um arquivo, e ofstream, que significa fluxo de arquivo de saída, é usado para gravar um fluxo de dados em um arquivo.
O arquivo iostram.h contém todas as classes de fluxo de entrada / saída padrão necessárias na linguagem de programação C ++.
Exemplos
Agora que você entende os fundamentos de streams, discutiremos os exemplos a seguir para ajudá-lo a entender melhor as operações de arquivo em C ++:
- Exemplo 1: abrir e fechar um arquivo
- Exemplo 2: gravar em um arquivo
- Exemplo 3: ler de um arquivo
- Exemplo 4: ler e gravar em um arquivo
- Exemplo 5: leitura e gravação em um arquivo binário
Exemplo 1: abrir e fechar um arquivo
Neste programa de exemplo, demonstraremos como abrir / criar um arquivo e como fechar o arquivo em C ++. Como você pode ver no programa abaixo, incluímos a biblioteca necessária para as operações de arquivo.
Para abrir e fechar um arquivo, precisamos de um objeto ofstream. Então, para ler ou escrever em um arquivo, temos que abrir o arquivo. Incluímos o arquivo de cabeçalho fstream na linha número 1 para que possamos acessar a classe ofstream.
Declaramos um myFile_Handler como um objeto ofstream dentro da função principal. Podemos então usar a função open () para criar um arquivo vazio e a função close () para fechar o arquivo.
#incluirusando namespacehoras;
inta Principal()
{
ofstream myFile_Handler;
// Arquivo aberto
myFile_Handler.abrir('File_1.txt');
// Arquivo Fechar
myFile_Handler.fechar();
Retorna 0;
}
Agora, compilaremos o programa e examinaremos a saída. Como você pode ver na janela de saída abaixo, o arquivo File_1.txt foi criado após a execução do programa. O tamanho do arquivo é zero, pois não gravamos nenhum conteúdo no arquivo.
Exemplo 2: gravar em um arquivo
No programa de exemplo anterior, mostramos como abrir e fechar um arquivo. Agora, mostraremos como escrever algo em um arquivo.
Podemos escrever em um arquivo usando o operador de inserção de fluxo, ou seja,<<. In this program, we have used the file handler and insertion operator to write two lines in the file. The insertion operator (<<) indicates that we are inserting the string into the output file stream object.
#incluirusando namespacehoras;
inta Principal()
{
ofstream myFile_Handler;
// Arquivo aberto
myFile_Handler.abrir('File_1.txt');
// Grava no arquivo
myFile_Handler<< 'Este é um arquivo de teste de amostra. ' <<endl;
myFile_Handler<< 'Esta é a segunda linha do arquivo. ' <<endl;
// Arquivo Fechar
myFile_Handler.fechar();
Retorna 0;
}
Agora, vamos compilar o programa acima e executá-lo. Como você pode ver abaixo, gravamos com sucesso no arquivo File_1.txt.
Exemplo 3: ler de um arquivo
Nos exemplos anteriores, mostramos como gravar conteúdo em um arquivo. Agora, vamos ler o conteúdo do arquivo que criamos no Exemplo-2 e exibir o conteúdo no dispositivo de saída padrão, ou seja, o monitor.
Usamos a função getline () para ler a linha completa do arquivo e depois cout para imprimir a linha no monitor.
#incluir#incluir
#incluir
usando namespacehoras;
inta Principal()
{
ifstream myFile_Handler;
string myLine;
// Arquivo aberto no modo de leitura
myFile_Handler.abrir('File_1.txt');
E se(myFile_Handler.está aberto())
{
// Continue lendo o arquivo
enquanto(Obter linha(myFile_Handler, myLine))
{
// imprime a linha na saída padrão
custo <<minha linha<<endl;
}
// Arquivo Fechar
myFile_Handler.fechar();
}
outro
{
custo << 'Incapaz de abrir o arquivo!';
}
Retorna 0;
}
Agora, imprimiremos o conteúdo de Arquivo_1.txt usando o seguinte comando: cat Arquivo_1.txt. Depois de compilar e executar o programa, fica claro que a saída corresponde ao conteúdo do arquivo. Portanto, lemos o arquivo com sucesso e imprimimos o conteúdo do arquivo no monitor.
Exemplo 4: ler e gravar em um arquivo
Até agora, mostramos como abrir, ler, escrever e fechar um arquivo. Em C ++, também podemos ler e gravar em um arquivo ao mesmo tempo. Para ler e escrever em um arquivo, temos que obter um objeto fstream e abrir o arquivo no modo ios :: in e ios :: out.
Neste exemplo, primeiro gravamos algum conteúdo no arquivo. Em seguida, lemos os dados do arquivo e os imprimimos no monitor.
#incluir#incluir
#incluir
usando namespacehoras;
inta Principal()
{
fstream myFile_Handler;
string myLine;
// Arquivo aberto
myFile_Handler.abrir('File_1.txt', ios::no |ios::Fora);
// Verifique se o arquivo foi aberto
E se(!myFile_Handler)
{
custo << 'Arquivo não aberto!';
saída(1);
}
// Grava no arquivo
myFile_Handler<< '1. Este é outro arquivo de teste de amostra. ' <<endl;
myFile_Handler<< '2. Esta é a segunda linha do arquivo. ' <<endl;
myFile_Handler.searchg(ios::implorar);
// Leia o arquivo
E se(myFile_Handler.está aberto())
{
// Continue lendo o arquivo
enquanto(Obter linha(myFile_Handler, myLine))
{
// imprime a linha na saída padrão
custo <<minha linha<<endl;
}
// Arquivo Fechar
myFile_Handler.fechar();
}
outro
{
custo << 'Incapaz de abrir o arquivo!';
}
myFile_Handler.fechar();
Retorna 0;
}
Agora, iremos compilar e executar o programa.
Exemplo 5: leitura e gravação em um arquivo binário
Neste exemplo, vamos declarar uma classe e, em seguida, gravar o objeto em um arquivo binário. Para simplificar este exemplo, declaramos a classe Employee com uma variável pública emp_id. Então, vamos ler o arquivo binário e imprimir a saída no monitor.
#incluir#incluir
usando namespacehoras;
classeEmpregado
{
público:
intemp_id;
};
inta Principal()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Funcionário empObj_W, empObj_R;
// Arquivo aberto
binOutFile_Handler.abrir('funcionário.dat', ios::Fora |ios::binário);
// Verifique se o arquivo foi aberto
E se(!binOutFile_Handler)
{
custo << 'Arquivo não aberto!';
saída(1);
}
// Inicialize empObj_W
empObj_W.emp_id = 1512;
// Grava no arquivo
binOutFile_Handler.escrever((Caracteres *) EempObj_W,tamanho de(Empregado));
binOutFile_Handler.fechar();
E se(!binOutFile_Handler.Boa())
{
custo << 'Ocorreu um erro durante a gravação do arquivo binário!' <<endl;
saída(2);
}
// Agora, vamos ler o arquivo employee.dat
binInFile_Handler.abrir('funcionário.dat', ios::no |ios::binário);
// Verifique se o arquivo foi aberto
E se(!binInFile_Handler)
{
custo << 'Arquivo não aberto!';
saída(3);
}
// Leia o conteúdo do arquivo binário
binInFile_Handler.leitura((Caracteres *) EempObj_R,tamanho de(Empregado));
binInFile_Handler.fechar();
E se(!binInFile_Handler.Boa())
{
custo << 'Ocorreu um erro durante a leitura do arquivo binário!' <<endl;
saída(4);
}
// Imprime a saída de empObj_R
custo << 'Detalhes do empregado:' <<endl;
custo << 'ID do Empregado : ' <<empObj_R.emp_id <<endl;
Retorna 0;
}
Conclusão
Os arquivos são usados principalmente para armazenar os dados e desempenham um papel importante na programação do mundo real. Neste artigo, mostramos como usar várias operações de arquivo com a linguagem de programação C ++, trabalhando com vários exemplos. Além disso, mostramos como ler e gravar dados em arquivos de texto e arquivos binários.