Apostila - Programa--o C++
169 pág.

Apostila - Programa--o C++


DisciplinaAnálise Textual9.567 materiais293.977 seguidores
Pré-visualização50 páginas
dois 
inteiros como argumentos. Esta restrição previne a redefinição de operadores internos da 
linguagem. Alguns operadores não podem ser defindos como funções amigas; devem ser definidos 
como funções-membro de classe. São eles: atribuição (=), acesso de membros de ponteiros (->), 
() e conversores de tipo. 
17.6 Exercícios 
17.1 Escreva as classes Animal, Vaca, Bufalo e Bezerro, sendo Vaca e Bufalo derivadas de 
Animal e Bezerro derivada de Vaca e de Bufalo. 
 
17.2 Modele os elementos Veículos, Moto, Carro Esportivo, Carro de Luxo, Carro Popular, 
Perua, Carro Mil, Jipe, Caminhão, Onibus e Caminhonete. Utilize a idéia do exercício 16.3. Crie um 
programa que controle uma revenda de carros. Tenha uma lista única contendo todos os veículos a 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 138 
venda. Utilize o princípio de um vetor de ponteiros para a classe base e emprege exaustivamente os 
conceitos da derivação e de funções virtuais e amigas. Permita que o usuário insira algum veículo 
na lista, faça consultas, liste todos os veículos disponíveis e retire um veículo da lista. 
 
17.3 Defina uma classe String que sobrecarrega os seguintes operadores para as mais 
variadas funções: (+), (==), (!=), (<), (>), (<=), (>=), (<<) e (>>). 
 
17.4 Refaça os exercícos 16.1 e 16.2 empregando o princípios das funções amigas e virtuais. 
 
 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 139 
18 Operações com Arquivos Iostream 
Neste capítulo, veremos brevemente as facilidades de C++ para operações de leitura e 
gravação em discos. Começaremos com uma breve descrição das classes usadas para executar esta 
tarefa, conhecidas como classes iostream. 
Em C++, os objetos stream são o ponto central das classes iostream. Um objeto stream pode 
ser pensado como um buffer para o recebimento ou envio de bytes. Desta forma, um arquivo em 
disco é um objeto stream. O conceito de arquivo é ampliado no sentido de considerar arquivos não 
somente os que existem em discos mas também o teclado, o vídeo, a impressora e as portas de 
comunicação. Por exemplo, o objeto cout representa o vídeo (recebimento de bytes) e o objeto cin 
representa o teclado (envio de bytes). As classes iostream interagem com esses arquivos. 
Diferentes objetos stream são usados para representar diferentes interações com periféricos 
de entrada e saída. Cada stream é associado a uma classe particular, caracterizada pelas suas 
funções de interface e pelos seu operadores de inserção e extração. 
Na Figura 4 apresentamos a hierarquia das classes iostream. Por exemplo, cout é um objeto 
da classe ostream_withassign que é derivada da classe ostream. Similarmente, cin é um objeto da 
classe istream_withassign que é derivada da classe istream. Objetos de destino de bytes usam o 
operador de inserção <<, membro da classe ostream. Os objetos de origem de bytes usam o 
operador de extração <<, membro da classe istream. Estas duas classes são derivadas da classe ios. 
Para descobrir os arquivos que definem estas classes, utilize o help do seu compilador pois a nova 
norma ANSI C++ definiu novos nomes para estes headers. 
 
Figura 4 : Hieraquia das Classes Iostream do ANSI C++ obtidas pelo Help do Visual C++ 6.0. 
A classe ios é a base para todas as outras classes. Ela contém várias constantes e funções-
membro para as operações de leitura e impressão a todas as outras classes. 
As classes iostream e ostream são derivadas de ios e são dedicadas a leitura e impressão, 
respectivamente. Suas funções-membro implementam operações formatadas ou não-formatadas em 
objetos stream. A classe istream contém funções como get(), getline(), read(), além de outras. 
Contém ainda a sobrecarga do operador de extração >>. Já a classe ostream contém funções como 
put(), write(), além de outras. Contém ainda a sobrecarga do operador de inserção <<. Todo objeto 
istream ou ostream contém um objeto streambuf derivado. As classes istream e ostream trabalham 
em conjunto com a classe streambuf. 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 140 
A classe iostream é derivada das classes istream e ostream por meio de herança múltipla. 
Desta forma, esta classe herda as capacidades tanto de leitura como de impressão. Outras classes 
podem ser criadas pelo usuário tendo como base istream e ostream. 
As classes istream_withassign e ostream_withassign são usadas para a entrada e a saída 
padrão. Os objetos cin e cout são objetos destas classes. 
As classes istrstream, ostrstream e strstream são usadas na manipulação de buffers de dados: 
para leitura, para gravação e para leitura/gravação respectivamente. 
As classes ifstream, ofstream e fstream são usadas na manipulação de arquivos em disco 
para leitura, para gravação e para leitura e gravação respectivamente. 
18.1 Estudo de Caso 
Vamos apresentar a leitura e escrita de arquivos a partir de um exemplo. O exemplo tratado 
é a classe Pessoa definida nos capítulos anteirores. A classe em si não apresenta nada de novo, 
somente sobrecarregamos os operadores de inserção << e extração >> de dados definidos para 
objetos da classe iostream. A sobrecarga destes operadores nos permite o escrita e a leitura 
automática de dados da classe, utilizando-se estes operadores. O header fstream.h foi adicionado 
por causa das classes de manipulação de arquivos. Veja o exemplo abaixo. 
 
// Exemplo da class fostream 
#include <iostream> 
#include <fstream> 
#include <iomanip> 
#include <string> 
using namespace std; 
 
#define Nome_Size 80 
 
class Pessoa 
{ 
protected: 
 char * Nome; 
 int Idade; 
 long int RG; 
 
public: 
 Pessoa(); 
 Pessoa(char * aNome, int aId = 0, long int aRG = 0); 
 Pessoa(Pessoa const & aP); 
 ~Pessoa(); 
 
 char const * GetNome() const { return Nome; } 
 int GetIdade() const { return Idade; } 
 long int GetRG() const { return RG; } 
 
 void GetData(); 
 
 friend ostream & operator <<(ostream & OS, Pessoa const & P); 
 friend istream & operator >>(istream & IS, Pessoa & P); 
}; 
 
Pessoa::Pessoa() 
{ 
 Nome = new char[Nome_Size]; 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 141 
 Idade = 0; 
 RG = 0; 
} 
 
Pessoa::Pessoa( char * aNome, int aId, long int aRG) 
{ 
 Nome = new char[Nome_Size]; 
 strcpy( Nome, aNome); 
 Idade = aId; 
 RG = aRG; 
} 
 
Pessoa::Pessoa(Pessoa const & aP) 
{ 
 Nome = new char[Nome_Size]; 
 strcpy( Nome, aP.GetNome()); 
 Idade = aP.GetIdade(); 
 RG = aP.GetRG(); 
} 
 
Pessoa::~Pessoa() 
{ 
 if(Nome != 0) 
 { 
 delete Nome; 
 Nome = 0; 
 } 
} 
 
void Pessoa::GetData() 
{ 
 cout << &quot;\nNome : &quot;; 
 cin.getline( (char *)Nome, Nome_Size); 
 cout << &quot;Idade : &quot;; 
 cin >> Idade; 
 cout << &quot;RG : &quot;; 
 cin >> RG; 
} 
 
ostream & operator <<(ostream & OS, Pessoa const & P) 
{ 
 OS << P.GetNome() 
 << &quot;\n&quot; << P.GetIdade() 
 << &quot;\n&quot; << P.GetRG(); 
 return OS; 
} 
 
istream & operator >>(istream & IS, Pessoa & P) 
{ 
 IS.getline( (char *)P.Nome, Nome_Size); 
 IS >> P.Idade; 
 IS >> P.RG; 
 return IS; 
} 
 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 142 
int main(int argc, char* argv[]) 
{ 
 Pessoa Eu(&quot;Rodrigo&quot;, 20, 231123); 
 
 // Escrevendo 
 ofstream FOut(&quot;Teste.TXT&quot;, ios::out); 
 FOut << Eu << &quot;\n Um dia a casa cai! \n &quot; 
 << setw(12) << setprecision(3) << 12.2345; 
 FOut.close(); 
 
 // Lendo