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

Apostila - Programa--o C++


DisciplinaAnálise Textual9.941 materiais293.773 seguidores
Pré-visualização50 páginas
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 155 
template<class T> class Vector<T*>:private Vector<void*>{//...}; 
 
20.5 Polimorfismo 
Polimorfismo está presente em ambas classes abstratas e templates. A implementação de 
códigos de templates é idêntica para todos os tipos de parâmetros. Por outro lado, as classes 
abstratas definem uma interface comum para todas as classes derivadas. 
Como ambas permitem que um algoritmo possa ser definido uma vez e aplicado para 
diferentes tipos, nós podemos defini-las como polimórficas. Para distingui-las, o que funções 
virtuais realizam é chamado polimorfismo em tempo de execução, e o que as templates realizam é 
chamado de polimorfismo em tempo de compilação ou polimorfismo paramétrico. 
Para escolher entre as duas opções, nós precisamos analisar o seguinte: 
\u2022 se nenhuma relação hierárquica entre os objetos é necessário, melhor usar templates; 
\u2022 se os tipos de dados dos objetos não são conhecidos em tempo de compilação, então é 
melhor representá-los por classes derivadas de uma classe abstrata. 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 156 
21 Conteiner 
Um container é um objeto que contém outros objetos. Exemplos são listas, vetores e arrays 
associativos. Em geral, você pode adicionar objetos a um container e remover objetos dele. 
Estes elementos podem ser de qualquer tipo de objeto que tenha um construtor default, um 
destruidor e um operador de atribuição. 
21.1 Iteradores 
Para ter acesso ao conteúdo dos containeres da mesma maneira com que se acessa arrays 
convencionais, é necessário o uso de iteradores. Eles nos possibilitam navegar no conteúdo dos 
containeres sem nos preocupar com seu conteúdo. A STL inclui vários tipos de iteradores, incluindo 
iteradores de acesso aleatório, reversos e iteradores iostream. 
21.2 Tipos de Conteineres 
21.2.1 Conteineres Seqüenciais 
São objetos que armazenam outros objetos num arranjo estritamente linear. 
\u2022 vector<T> : Permite o acesso aos dados como se fosse um array para uma seqüência 
de dados de tamanho variável, com inserções e destruições no final com tempo 
constante; 
\u2022 deque<T> : Permite o acesso aleatório à uma seqüência de dados de tamanho 
variável, com inserções e destruições com tempo constante no início e no final; 
\u2022 list<T> : Permite o acesso aos dados em tempo linear para uma seqüência de dados de 
tamanho variável, com inserções e destruições de tempo constante em qualquer ponto da 
seqüência. 
21.2.2 Contêineres Associativos: 
Possibilitam uma rápida recuperação de objetos da coleção baseado em chaves. O tamanho 
da coleção pode variar em tempo de execução. A coleção é mantida em ordem baseado em um 
objeto função de comparação do tipo Compare : 
\u2022 set<T, Compare> : Suporta chaves únicas (contém no máximo uma chave com cada 
valor) e dá acesso rápido para recuperas as chaves; 
\u2022 multiset<T, Compare> : Suporta chaves duplicadas (pode conter múltiplas 
cópias do mesmo valor de chave) e dá acesso rápido para recuperas as chaves; 
\u2022 map<T, Compare> : Suporta chaves únicas (contém no máximo uma chave com 
cada valor) e dá acesso rápido a outro tipo T baseado nas chaves; 
\u2022 multmap<T, Compare> :Suporta chaves duplicadas (pode conter múltiplas cópias 
do mesmo valor de chave) e dá acesso rápido a outro tipo T baseado nas chaves. 
21.3 Exemplo de Conteiner 
No seguinte exemplo, um vetor v é construído e algumas operações são feitas com ele. 
 
#include <iostream> 
#include <vector> 
using namespace std; 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 157 
 
void pause() 
{ 
char lixo; 
cout << &quot;\nPress any key to continue&quot;; 
cin >> lixo; 
} 
 
void printvector(vector<int> v) 
{ 
 int i=0; 
 cout << &quot;Vector: &quot;; 
 for (i=0; i < v.size(); i++) 
 cout << v[i] << &quot; &quot;; 
 cout << &quot;\n&quot;; 
} 
 
int main(int argc, char* argv[]) 
{ 
cout << &quot;Programa exemplo de contaneres\n\nvector<int> v(3,2)\n&quot;; 
vector< int > v(3,2); 
// Declara v como container vector do tipo int 
printvector(v); 
pause(); 
 
cout << &quot;\nv.push_back(5); 
// Insere o elemento 5 no final da sequencia\n&quot;; 
v.push_back(5); 
// Insere o elemento 5 no final da sequencia 
printvector(v); 
pause(); 
 
cout << &quot;\nInserindo mais elementos...\n&quot;; 
v.push_back(3); 
v.push_back(7); 
v.push_back(15); 
v.push_back(1); 
printvector(v); 
pause(); 
 
cout << &quot;\nv.pop_back(5); 
// Apaga o elemento do final da sequencia\n&quot;; 
v.pop_back(); 
// Apaga o elemento do final da sequencia 
printvector(v); 
pause(); 
return 0; 
} 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 158 
22 Exceptions Handling 
Mesmo após o esforço de depuração da lógica e do código do software, situações 
excepcionais não previstas podem ocorrer durante a execução do programa e fazerem com que o 
programa incorra em erros ou até mesmo termine abruptamente. 
Embora de tais situações, como falta de memória, entrada de dados incorretos, perda de 
linha do modem, disco fora da unidade, arquivo inexistente, entre outras, não possam ser evitadas 
pelo programador, ele deve se preparar para tratá-las da melhor maneira possível se por ventura 
vierem a ocorrer. 
As opções existentes quando da ocorrência de algum evento como esse são: 
\u2022 Derrubar o programa; 
\u2022 Informar a ocorrência ao usuário e finalizar o programa; 
\u2022 Informar a ocorrência ao usuário e permitir que ele tente reparar o erro e continuar a 
execução do programa; 
\u2022 Executar uma ação corretiva automática e prosseguir sem avisar o usuário. 
 
Derrubar o programa é o que acontece por default quando uma exceção não é chamada 
entretanto, para a maioria dos erros é possível fazer melhor que isto. 
No caso de chamadas de funções que retornam algo, não se pode checar os valores a cada 
chamada, pois isso pode facilmente dobrar o tamanho do programa. 
O Tratamento de Exceções do C++ possibilita ao programador combater e tratar da melhor 
forma essas ocorrências, que apesar de insólitas, podem, na maioria das vezes, serem previstas 
durante a fase de projeto do software. 
22.1 Exceção 
Em C++ uma exceção é um objeto que é passado da área de código onde ocorre um erro 
(geralmente em um nível muito baixo do programa) para a parte do código que irá tratar o problema 
(normalmente um nível mais alto do programa, com código para interação com o usuário). 
22.2 Como as exceções são usadas 
Blocos try são criados para cercar áreas de código que podem conter um problema, da 
seguinte maneira: 
 
try 
{ 
 Função_Perigosa(); 
} 
 
Blocos catch tratam as exceções aplicadas ao bloco-try: 
 
try // como feito anteriormente 
{ 
 Função_Perigosa(); 
} 
 
catch(SemMemoria) 
{ 
 //Ações a serem tomadas 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 159 
} 
 
catch(ArquivoNaoEncontrado) 
{ 
 //Outras ações 
} 
 
Os passos básicos da utilização de exceções são: 
1. Identificar aquelas áreas do programa nas quais existe uma operação que pode levantar 
uma exceção e inserí-las em um bloco try.É interessante ressaltar que essa tarefa pode 
ser uma das mais trabalhosas do processo de tratamento do exceções. 
2. Criar tantos blocos catch quanto necessários para apanhar as exceções que forem 
aplicadas, limpar a memória alocada e passar as informações apropriadas ao usuário. 
 
Os blocos try cercam as áreas do código onde podem ocorrer problemas, entretanto é 
preciso que as funções ou \u201csub funções\u201d chamadas nessas áreas estejam aptas a requisitar a exceção 
caso aconteça algum