Apostila C - C++
170 pág.

Apostila C - C++


DisciplinaIntrodução à Tecnologia da Computação26 materiais155 seguidores
Pré-visualização50 páginas
\u2013 DAS \u2013 CTC \u2013 UFSC 142
int main(int argc, char* argv[]) 
{ 
Pessoa Eu("Rodrigo", 20, 231123); 
// Escrevendo 
ofstream FOut("Teste.TXT", ios::out); 
FOut << Eu << &quot;\n Um dia a casa cai! \n &quot; 
 << setw(12) << setprecision(3) << 12.2345; 
FOut.close(); 
// Lendo 
ifstream FIn; 
Fin.open(&quot;Teste.TXT&quot;, ios::in) 
Pessoa Vc; 
char Buffer[Nome_Size]; 
FIn >> Vc; 
cout << &quot;\nVoce: \n&quot; << Vc; 
while(FIn) //Enquanto nao acabar o arquivo 
{ 
 FIn.getline( Buffer, Nome_Size); 
 cout << &quot;\nBuffer : &quot; << Buffer; 
} 
FIn.close(); 
Return 0; 
} 
Na funçao main( ) é que aparecem as novidades. Primeiro criamos um objeto Pessoa. Depois 
escrevemos este objeto e outros dados em um arquivo e depois prosseguimos com a leitura deste. 
Neste programa definimos um objeto chamado Fout da classe ofstream. Inicializamos este 
objeto com o nome do arquivo \u201cTESTE.TXT\u201d. Esta inicialização associa o objeto Fout ao arquivo 
em disco \u201cTESTE.TXT\u201d para gravação e já abre o arquivo. O segundo parâmetro indica que o 
arquivo será aberto para a escrita. 
Note que escrevemos os dados no arquivo da mesma forma que escrevemos os dados na tela 
com cout. Toda formatação e função válida para cout também pode ser aplicada a FOut. Desta 
forma, utilizamos o mesmo operador definido para escrever os dados da classe Pessoa na tela como 
em um arquivo. Esta facilidade advém do fato de cout e FOut serem ambos objetos de classes 
derivadas da classe ostream. 
Após a escrita dos dados, devemos fechar o arquivo com a função close(). É neste momento 
que os dados serão salvos no arquivo. Se você não fechar o arquivo, os dados somente serão salvos 
quando o objeto for destruído e o arquivo, então, será fechado pelo destrutor do objeto. 
Para ler o arquivo, criamos um objeto da classe ifstream de nome Fin e associamos este 
objeto ao arquivo Teste.TXT através da função open(). O segundo parâmetro indica que este 
arquivo será aberto para a leitura. Note que o construtor não abrirá nenhum arquivo aqui, somente 
após a chamada a função open() é que o arquivo estará aberto. 
Depois utilizamos a sobrecarga do operador >> para fazer a aquisição dos dados da classe 
Pessoa contido no referido arquivo e imprimir na tela. Após termos lidos o dado da classe, 
prosseguimos lendo linha por linha do arquivo e escrevendo-a na tela até terminar o arquivo. Note 
que fazemos uso da função getline(), que recebe um buffer como parâmetro e adquire uma linha 
inteira do arquivo. 
Os objetos da classe ifstream tem um valor que pode ser testado para a verificação do fim-
de-arquivo. O objeto FIn terá o valor zero se o sistema operacional enviar ao program o sinal de 
Curso de Linguagem Computacional C/C++
 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 143
fim-de-arquivo e um valor não-zero caso contrário. O programa verifica o término do arquivo no 
laço while. A função eof() desta classe poderia ser empregada com o mesmo propósito. 
Após lermos o arquivos, fechamos este através da função close(). 
Todas as funções definidas para a leitura e escrita em C podem ser empregadas em C++. 
Estas funções foram incorporadas nas classes iostream. Verifique com o help do seu compilador as 
funções disponíveis e verificará esta observação. Por exemplo, o função put() foi adicionada a 
classe ostream, e pode ser acessada da forma: 
cout.put(\u2018c\u2019); ou FOut.put(\u2018c\u2019); 
O controle do formato da impressão e leitura pode ser executado por meio dos 
manipuladores e flags da classe ios. Estes mecanismos foram apresentados em 13.4 e se aplicam 
para todos os objetos streams. 
18.2 A função Open() 
Quando usamos um objeto da classe ofstream ou ifstream, é necessário associá-lo a um 
arquivo. Esta associação pode ser feita pelo construtor da classe ou usando a função open(), 
membro da classe fstream, numa instrução após a criação do objeto com o construtor default. 
Tanto o construtor como a função open() aceitam a inclusão de um segundo argumento 
indicando o modo de abertura do arquivo. Este modo é definido por bits de um byte, onde cada um 
especifica um certo aspecto de abertura do arquivo. A lista de modos é definida na classe ios por 
meio de enum open_mode: 
Modos Descrição 
ios::in Abre para leitura (default de ifstream) 
ios::out Abre para gravação (default de ofstream) 
ios::ate Abre e posiciona no final do arquivo \u2013 leitura e gravação 
ios::app Grava a partir do fim do arquivo 
ios::trunc Abre e apaga todo o conteúdo do arquivo 
ios::nocreate Erro de abertura se o arquivo não existir 
ios::noreplace
 
Erro de abertura se o arquivo existir. 
ios::binary Abre em binário (default é texto). 
 
Podemos trabalhar com arquivos no modo texto ou no modo binário, assim como em C. 
Lembre-se que o fim de linha em modo texto é representado por um único caractere, enquanto em 
modo binário é representado por dois caracteres. 
Exemplos: 
ifstream fin(\u201cTeste.txt\u201d, ios::in|ios::binary); 
fstream fio; \\ Arquivo para leitura e gravaçao!!!! 
fio.open(\u201cLista.dat\u201d, ios::in|ios::out|ios::ate); 
18.3 Testando Erros 
Situações de erros na manipulação de arquivos podem ser previstas verificando-se a palavra 
(int) de status da classe ios. A palavra de status pode ser obtida pela função rdstate(), membro da 
classe ios. Os bits individuais do valor retornado podem ser testados pelo operador AND bit-a-bit 
(&) e os seguintes valores enumerados: 
Bits Função Comentário 
ios::goodbit good() Nenhum bit setado. Sem erros 
Curso de Linguagem Computacional C/C++
 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 144
ios::eofbit eof() Encontrado o fim-de-arquivo 
ios::failbit fail() Erro de leitura ou gravação 
ios::badbit bad() Erro irrecuperável 
 
A função clear(int status) modifica a palavra de status. Se usada sem argumento, todos os 
bits de erros são limpos. Do contrário, os bits setados de acordo com os valores enumerados 
escolhidos e combinados pelo operador OR (|): 
clear(ios::eofbit | ios::failbit); 
18.4 Escrevendo e Lendo em Buffers de Caracteres 
As classes iostream interagem com a memória pela mesma sintaxe com a qual interagem 
com arquivos de disco. Podemos ler e grava de e para buffers de caracteres na memória do 
computador. Veja o exemplo abaixo, onde criamos um objeto ostrstream para criar um buffer e 
adicionar dados neste buffer. Depois armazenamos o ponteiro deste buffer em uma variável. Em 
seguida, criamos um objeto istrstream para ler dados do mesmo, passando para o seu construtor o 
ponteiro do buffer. Por fim, imprimimos os dados na tela. 
// StrStream 
#include <iostream> 
#include <strstrea> 
using namespace std; 
int main(int argc, char* argv[]) 
{ 
ostrstream OS; // Cria buffer para a escrita 
OS << &quot;123.45 \t&quot; << 555.55 << &quot;\t&quot; << 333; 
OS << &quot;\n\n Sorte = Estar_Preparado + Oportunidade!&quot;; 
OS << ends; 
char * ptr = OS.str(); 
double x, y; 
int i; 
istrstream IS(ptr); 
IS >> x >> y >> i; 
cout << x << '\t' << y << '\t' << i << '\n' << ptr; 
return 0; 
} 
Note a semelhança da metodologia. O manipulador ends, usando neste exemplo, adiciona o 
terminador \u2018\0\u2019 à cadeia de caracteres. 
Estas classes podem ser usadas para aproveitarmos os operadores << e >> para converter 
qualquer tipo de dado no formato texto ASCII e armazenar em um buffer de caracteres. Este buffer 
pode ser utilizado para transmitir estes dados para a tela do micro, ou para uma porta COM ou até 
para um outro processo via conexões TCP/IP da internet. Definindo o operador << e >> para toda 
classe, definimos um modo padrão para a escrita/leitura dos dados de uma classe para um arquivo, 
um buffer, ou um canal de I/O qualquer. Esta é uma ferramenta muito poderosa que não pode ser 
desprezada e, quando bem aproveitada, gera código velozes, simples e com alta flexibilidade. 
Curso de Linguagem Computacional