Programação Estruturada 2 - Aula 04

Programação Estruturada II
Aula 04 – Arquivos
Prof. Thomás da Costa
thomasdacosta@gmail.com
Anhanguera – 2015.1

PEA - Programação Estruturada II
Vamos ver o PEA:
Antes de iniciar a aula, vamos mostrar o andamento do PEA. Vou mostrar as aulas
lecionadas e vamos ver as próximas lições até o fim do curso.
Prof. Thomás da Costa Programação Estruturada II
Vamos ver o que aprendemos
até agora !!!

Status Matéria
Apresentação da disciplina. Revisão de aspectos básicos da linguagem C.
Depuração e documentação interna de programas.
Conceituação de modularização. Utilização de Funções. Passagem de
parâmetros por valor.
Utilização de Funções. Passagem de parâmetros por referência. Exemplos e
exercícios.
Definição de tipos. Tipos definidos pelo programador. Utilização do tipo struct.
Conceituação, principais utilizações, exemplos e exercícios.
Abordagem dos tipos union e enum. Conceituação, principais utilizações,
exemplos e exercícios.
Revisão
Atividades de Avaliação.

Vamos ver as próximas aulas
até o fim do curso !!!

Status Matéria
Introdução a arquivos de dados. Conceito de campos e registros. Criação de registros e criação de
arquivos.
Operações com arquivos: inclusão de registro, consulta a registros. Fechamento de arquivos.
Exemplos e exercícios.
Operações com arquivos: exclusão de registros, alterações de registros. Exercícios em sala.
Exercícios com arquivos.
Conceito de recursividade. Aplicações. Exemplos de programas recursivos.
Recursão: exercícios.
Introdução a ponteiros e suas aplicações. Exemplos e exercícios em sala.
Tipos de ponteiros. Utilização de operadores aritméticos e de comparação em ponteiros. Exercícios.
Introdução a Ponteiros avançados e operadores bit-a-bit
Ponteiros avançados e operadores bit-a-bit. Exemplos e exercícios.
Revisão
Prova Escrita Oficial
Prova Substitutiva

Avaliação – B2
Avaliação – B2
- Período das avaliações B2: 15 até 19 de Junho
- Data da Avaliação B2: 15 de junho (SIS) e 16 de junho (TADS)
- Obrigatoriamente, avaliação da B2 é PROVA
- PROVA SUBSTITUTIVA SUBSTITUI A NOTA DA B2, NÃO SUBSTITUI A MENOR NOTA
DAS PROVAS OU A B1
- Matéria da Prova é todo o conteúdo do semestre
- Será disponibilizado uma lista com 20 exercícios para estudar

ATPS – B2
ATPS – B2
- Data de Entrega B2: 08 de junho (SIS) e 09 de junho (TADS)
- O prazo para entrega é até as 20h50 do dia 08 (SIS) e 09 (TADS)
- Fora desse horário não será aceito
- Grupo no máximo de 5 pessoas
- Efetuar a entrega da ETAPA 3 e ETAPA 4
- Fazer os exercícios em C++. Se for feito em C será considerado ERRADO
- Façam a REVISÃO do trabalho antes de imprimir e entregar
- Seguir a Normalização de Trabalhos Acadêmicos :
http://www.anhanguera.com/bibliotecas/biblioteca-virtual/pagina/normalizacao

Arquivos
ARQUIVOS

Arquivos
Bem conhecido no nosso dia-a-dia:
Todos os dias no nosso trabalho ou em casa utilizamos arquivos para armazenar
informações tais como: imagem, texto, trabalho de faculdade, relatórios, planilhas
de gastos e etc. Até esse ponto do curso, todas as informações eram armazenadas
na memória, ou seja, quando um programa terminava não existia nenhum
processo de armazenamento de dados.
Vamos aprender a armazenar informações em arquivos textos ou de dados !!!
Arquivos

Arquivos
Tipos de Arquivos:
Texto: armazena somente texto e caracteres. Normalmente possuem extensão txt
Binário: arquivos que podem armazenar textos, imagens, planilhas e outros tipos
de informações. Algumas extensões conhecidas: pdf, doc, xls, gif
Arquivos

Arquivos
Criando arquivos textos em C++:
Arquivos
#include <fstream>
...
ofstream ofs;
ofs.open("ola_mundo.txt", ios::out);
Include da biblioteca de arquivos
Variável do arquivo
Nome do arquivo
Formato de abertura do arquivo

#include <iostream>
#include <fstream>
#include <strings.h>
using namespace std;
void gravar_arquivo();
int main()
{
gravar_arquivo();
}
void gravar_arquivo()
{
string valor;
valor = "Ola Mundo";
ofstream ofs;
ofs.open("ola_mundo.txt", ios::out);
ofs << valor;
ofs.close();
}
Exemplo 1
Grava um texto no arquivo
O tipo string é semelhante a um vetor de char,
ou seja, armazena um conjunto de caracteres

Arquivos
Lendo arquivos textos em C++:
Arquivos
#include <fstream>
...
ifstream ifs;
ifs.open("ola_mundo.txt", ios::in);
Nome do arquivo

#include <iostream>
#include <fstream>
void ler_arquivo();
int main()
{
ler_arquivo();
}
void ler_arquivo()
{
string valor;
ifstream ifs;
ifs.open("ola_mundo.txt", ios::in);
if (!ifs.is_open())
{
cout << "Não foi possivel abrir o arquivo" << endl;
return;
}
getline(ifs, valor);
cout << "Conteúdo do Arquivo:" << valor << endl;
ifs.close();
}
Exemplo 2
Efetua a leitura de uma
linha no arquivo

Arquivos
Lembrete:
Sempre que um arquivo for aberto para leitura ou escrita, o mesmo deve ser
fechado, para que possa ser utilizado por outros programas e não ocupar recursos
do sistema operacional.
Arquivos
Utilizar o comando close() dos objetos
ofstream e ifstream !!!

Arquivos
Novos tipos e comandos:
string: novo tipo de variável, semelhante a um vetor de char
getline: efetua a leitura de uma linha de um arquivo
is_open: verifica se o arquivo foi aberto ou criado corretamente no disco. Exemplo
de problemas: falta de espaço em disco, diretório não existente e etc
Arquivos

#include <iostream>
#include <fstream>
int main()
{
gravar_arquivo();
}
{
int valor_1;
double valor_2;
float valor_3;
char valor_4;
cin >> valor_1;
cin >> valor_2;
cin >> valor_3;
cin >> valor_4;
ofstream ofs;
ofs.open("numeros.txt", ios::out);
ofs << valor_1 << endl;
ofs.close();
}
Exemplo 3
Lendo valores a partir do teclado
Gravando os valores sequencialmente

#include <iostream>
#include <fstream>
void ler_arquivo();
int main()
{
ler_arquivo();
}
void ler_arquivo()
{
int valor_1;
double valor_2;
float valor_3;
char valor_4;
ifstream ifs;
ifs.open("numeros.txt", ios::in);
if (!ifs.is_open())
{
return;
}
ifs >> valor_1;
ifs >> valor_2;
ifs >> valor_3;
ifs >> valor_4;
cout << "Valores do arquivo:" << valor_1 << ","
<< valor_2 << "," << valor_3 << "," << valor_4;
ifs.close();
}
Exemplo 4
Lendo os valores sequencialmente

Arquivos
Formas de abertura de um arquivo:
Quando trabalhamos com arquivos, existem várias formas de leitura e escrita.
Podemos abrir o arquivo somente para leitura, escrita, escrita/leitura e etc. Para
escolher a forma de trabalhar com o arquivo, passamos parâmetros na função
open do ofstream ou do ifstream conforme a tabela abaixo:
Arquivos
Parâmetro Descrição
ios::in Efetua operação de leitura de arquivo (Sempre usar no ifstream)
ios::out Efetua operação de escrita de arquivo (Sempre usar no ofstream)
ios::binary Cria um arquivo binário
ios::app Insere valores no fim do arquivo
ios::trunc Apaga o conteúdo do arquivo e substitui por um novo

#include <iostream>
#include <fstream>
void gravar_fim_arquivo();
int main()
{
gravar_fim_arquivo();
}
void gravar_fim_arquivo()
{
string valor;
valor = "Nova linha no arquivo";
ofstream ofs;
ofs.open("arquivo_linhas.txt", ios::out | ios::app);
ofs << valor << endl;
ofs.close();
}
Exemplo 5
Abre o arquivo para escrita e
insere valores no final do arquivo

Arquivos
Lendo um arquivo com várias linhas:
Normalmente um arquivo texto possui várias linhas de caracteres. Quando
desenvolvemos um programa para ler um arquivo, não temos ideia do seu
tamanho. Para efetuarmos a leitura do arquivo até o seu fim, utilizamos o
comando getline dentro de uma instrução while.
Arquivos
O comando getline busca sempre o
fim de linha

#include <iostream>
#include <fstream>
int main()
{
gravar_arquivo();
}
{
string valor;
ofstream ofs;
ofs.open("arquivo_linhas.txt", ios::out);
valor = "O que são funções:";
valor = "São rotinas que tem como objetivo, "
"executar trechos de códigos de forma modular, "
"melhorando a organização do programa e evitando repetição de
código.";
valor = "As funções são reutilizáveis dentro de um programa.";
ofs.close();
}
Exemplo 6
Criando um arquivo com várias
linhas. No nosso caso, 3 linhas.

#include <iostream>
#include <fstream>
void ler_arquivo();
int main()
{
ler_arquivo();
}
void ler_arquivo()
{
string linha;
ifstream ifs;
ifs.open("arquivo_linhas.txt", ios::in);
if (!ifs.is_open())
{
return;
}
while (getline(ifs, linha))
{
cout << linha << endl;
}
ifs.close();
}
Exemplo 7
Utilizando getline para efetuar a leitura de
uma linha. Enquanto existir linha no
arquivo, a leitura será efetuada

Arquivos
Gravando estruturas em arquivo:
Até agora vimos como gravar informações no formato texto.
Neste ponto da matéria, iremos aprender a gravar um estrutura dentro de um
arquivo. A estrutura é gravado em um arquivo no formato binário
Para isso vamos aprender uma nova forma de trabalhar com arquivo. Essa nova
forma, podemos gravar e ler informações utilizando apenas um tipo de variável,
sem precisar usar o ofstream e o ifstream
Arquivos
Vamos ver a nova forma de gravação em arquivos !!!

#include <fstream>
...
fstream fst;
fst.open("registros.dat",
ios::in | ios::out | ios::app | ios::binary);
Arquivos
Escrevendo/Lendo arquivos textos e binários em C++:
Arquivos
Nome do arquivo

fst.write((char *)&alu, sizeof(alu));
Arquivos
Gravando uma estrutura em um arquivo:
Arquivos
Comando para gravação
“Cast” da estrutura para char
Tamanho da estrutura que será gravada

Exemplo 8
#include <iostream>
#include <fstream>
#include <limits>
struct alunos
{
long id;
char nome[255];
char ra[30];
int idade;
};
void gravar_arquivo_registros();
int main()
{
gravar_arquivo_registros();
}
void gravar_arquivo_registros()
{
alunos alu;
cout << "Digite o nome do aluno:";
gets(alu.nome);
cout << "Digite o RA do aluno:";
gets(alu.ra);
cout << "Digite a idade do aluno:";
cin >> alu.idade;
fstream fst;
if (!fst.is_open())
{
cout << "Não foi possivel abrir o arquivo"
<< endl;
return;
}
fst.write((char *)&alu, sizeof(alu));
fst.close();
}
Gravando uma estrutura no
arquivo

fst.read((char *)&alu,sizeof(alu))
Arquivos
Lendo uma estrutura em um arquivo:
Arquivos
Comando para leitura
“Cast” da estrutura para char
Tamanho da estrutura que será lida

Exemplo 9
#include <iostream>
#include <fstream>
#include <limits>
struct alunos
{
long id;
char nome[255];
char ra[30];
int idade;
};
void ler_arquivo_registros();
int main()
{
ler_arquivo_registros();
}
void ler_arquivo_registros()
{
alunos alu;
fstream fst;
if (!fst.is_open())
{
cout << "Não foi possivel abrir o arquivo";
return;
}
while (fst.read((char *)&alu,sizeof(alu)))
{
cout << "************************" << endl;
cout << "Nome:" << alu.nome << endl;
cout << "RA:" << alu.ra << endl;
cout << "Idade:" << alu.idade << endl;
}
fst.close();
}
Lendo uma estrutura do
arquivo

Arquivos
Resumo:
- Existem dois formatos de arquivos: texto e binário
- Utilizamos o tipo ofstream para escrita em um arquivo
- Utilizamos o tipo ifstream para leitura em um arquivo
- Podemos gravar uma estrutura em um arquivo
- O tipo fstream é utilizado para escrita e leitura de arquivos
- Devemos sempre fechar o arquivo com o close do tipo específico do arquivo
- O tipo string é semelhante a um vetor de char
- O comando getline efetua a leitura de uma linha em um arquivo texto
- O is_open tem como finalidade, indicar se o arquivo foi aberto ou criado
corretamente
- Para efetuar a leitura de um arquivo com várias linhas utilizamos o getline
dentro de laço até o final do arquivo
Arquivos

Arquivos
Próxima Aula:
- LABORATÓRIO !!!
- Vamos praticar os conhecimentos dessa aula
- O exercícios vão manter o mesmo padrão: básico, normal e avançado
- Iremos aprender matéria nova sobre arquivos no laboratório
Arquivos

Arquivos
Obrigado !!!

Programação Estruturada 2 - Aula 04

Mais conteúdo relacionado

Mais procurados (19)

Destaque (13)

Semelhante a Programação Estruturada 2 - Aula 04 (20)

Mais de thomasdacosta (20)

Último (17)

Programação Estruturada 2 - Aula 04