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

Apostila - Programa--o C++


DisciplinaOrganização de Computadores6.381 materiais119.712 seguidores
Pré-visualização50 páginas
evento inesperado. A exceção e aplicada utilizando a instrução throw, que 
pode passar qualquer tipo C++, inclusive objetos, para serem tratados por catch. 
O tratador é chamado somente se o tipo passado por throw é o mesmo tipo aceito por catch. 
Quando da chamada de um catch por um throw , é feita uma cópia do objeto passado para o 
tratador. 
O exemplo de código a seguir demonstra o uso do tratamento de exceções: 
 
#include <iostream> 
usind namespace std; 
 
void S2iFunc( void ); 
 
class S2iTest 
{ 
public: 
 S2iTest(){}; 
 ~S2iTest(){}; 
 const char* ShowReason() const { return &quot;Exceção na classe S2iTest!&quot;;} 
}; 
 
class S2iDemo 
{ 
public: 
 S2iDemo(); 
 ~S2iDemo(); 
}; 
 
S2iDemo:: S2iDemo() 
{ 
 cout << &quot;Construindo S2iDemo.&quot; << endl; 
} 
 
S2iDemo::~ S2iDemo() 
{ 
 cout << &quot;Destruindo S2iDemo.&quot; << endl; 
} 
 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 160 
void S2iFunc() 
{ 
 S2iDemo D; // cria um objeto da classe S2iDemo 
 cout<< &quot;Em S2iFunc(). Throwing a exceção S2iTest.&quot; << endl; 
 throw S2iTest(); //Envia um objeto da classe S2iTest para o tratador 
} 
 
int main(int argc, char* argv[]) 
{ 
 cout << &quot;Estamos em main.&quot; << endl; 
 try 
 { 
 cout << &quot;No bloco try, chamando S2iFunc().&quot; << endl; 
 S2iFunc(); 
 } 
 catch( S2iTest E ) //Recebe um objeto da classe S2iTest 
 { 
 cout << &quot;Estamos no tratador catch.&quot; << endl; 
 cout << &quot;Tratando exceção do tipo S2iTest: &quot;; 
 cout << E.ShowReason() << endl; 
 } 
 catch( char *str ) 
 { 
 cout << &quot;Trata outra exceção &quot; << str << endl; 
 } 
 cout << &quot;De volta a main. Execucao termina aqui.&quot; << endl; 
 return 0; 
} 
 
Saída do programa: 
 
Estamos em main. 
No bloco try, chamando S2iFunc(). 
Construindo S2iDemo. 
Em S2iFunc(). Throwing a exceção S2iTest. 
Destruindo S2iDemo. 
Estamos no tratador catch. 
Tratando exceção do tipo S2iTest: 
Exceção na classe S2iTest ! 
De volta a main. Execucao termina aqui. 
22.3 Biblioteca Except <except.h> 
Esta biblioteca dá suporte para exceções em ANSI C++. Algumas funções dessa classe são 
descritas a seguir. 
22.3.1 Terminate() 
void terminate(); 
 
A função terminate() pode ser chamada por outra função (como unexpected) ou pelo 
programa quando um tratador para uma exceção não for encontrado. A ação default para terminate 
é chamar abort, causando imediatamente o término do programa. 
O modo de término pode ser modificado utilizando-se de set_terminate. 
terminate() não retorna valor pois é uma função void. 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 161 
 
22.3.2 Set_terminate() 
typedef void (*terminate_function)(); 
terminate_function set_terminate(terminate_function t_func); 
 
Permite criar uma função que define o comportamento do término do programa se um 
tratador de exceção não for encontrado. 
As ações a serem realizadas em tal situação são definidas em t_func, que é declarada como 
uma função do tipo terminate_function. O tipo terminate_function é definido em <except.h> e é 
uma função que não recebe argumentos e retorna void. 
Se nenhum tratamento de exceção for encontrado, por default o programa chama a função 
terminate, resultando normalmente numa chamada para abort. Se o programador desejar uma outra 
ação, deve defini-la na função t_fun, que será instalada por set_terminate como a função de termino. 
22.3.3 Unexpected() 
void unexpected(); 
 
Se uma função envia uma exceção que não esta definida o programa chama unexpected. Se 
nenhuma ação especifica é e definida por set_unexpected, a função unexpected chama terminate. 
22.3.4 Set_unexpected() 
typedef void ( * unexpected_function )(); 
unexpected_function set_unexpected(unexpected_function unexpected_func) 
 
Essa função permite criar uma função que define o comportamento do programa se uma 
função envia (throw) uma exceção não especificada. As ações são definidas em 
unexpected_function. 
O tipo unexpected_function está definido em <except.h> e não recebe argumentos e 
retorna void. 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 162 
Trabalho 1 
Crie um programa que desenhe na tela o seu quadro de horários deste semestre. 
Trabalho 2 
A decomposição LDU é uma decomposição famosa de matrizes aplicada para calcular 
inversas de matrizes e resolver problemas de equações lineares. Utilize o programa 9.1 e crie um 
programa que calcule a decomposição LDU de uma matriz, preferencialmente, com pivotamento. 
Trabalho 3 
Crie um programa que faça o controle de cadastro de usuários e controle de alocação para 
uma locadora de fitas de vídeo. Utilize uma classe para os clientes e outra para as fitas, e emprege o 
método da lista ligada para gerenciar um vetor dinâmico. O usuário de poder incluir/retirar um 
cliente ou uma fita, fazer uma pesquisa, pedir a lista de clientes e a lista de fitas ou alterar algum 
parâmetro destas. 
Trabalho 4 
Este problema foi retirado do livro \u201cFundamentos da Automação Industrial Pneutrônica\u201d 
de Arno Bollmann (Professor da UFSC, Ed. ABHP \u2013 São Paulo). O objetivo aqui é utilizar uma 
ferramenta orientada a objetos para modelar, analisar e controlar um sistema pneumático 
automatizado. Enfocando a aplicação desta ferramenta na análise e desenvolvimento de sistemas 
automatizados. A ferramenta aplicada será a programação orientada a objetos em C++ juntamente 
com a técnica de modelagem UML. 
 
Manipulação de peças: alimentação de uma forja a partir de três fornos. 
 
A figura a seguir (Figura 5) apresenta o esquema de um sistema de manipulação de 
peças, cuja tarefa é a de alimentar uma forja com peças incandescentes apanhadas de três 
fornos, na medida em que os mesmos disponibilizem a peça na temperatura ajustada, sem 
ordem seqüencial predeterminada. 
 
Curso de Linguagem Computacional C/C++ 
________________________________________________________________________________________________ 
Sistemas Industriais Inteligentes \u2013 DAS \u2013 CTC \u2013 UFSC 163 
 
Figura 5 : O problema de manipulação de peças. 
Os fornos F1 e F2 e a entrada da Forja se situam num mesmo plano vertical, 
traseiro, enquanto que o forno F3 está mais à frente, num plano alcançado pelo avanço do 
atuador C. A forja e os fornos F1 e F3 estão numa posição mais alta, num mesmo plano 
horizontal, correspondendo à posição do atuador A recuado, como indicado na Figura 5. 
As peças podem ser colocadas aleatoriamente nos três fornos, com tempos de 
aquecimento não necessariamente iguais, fazendo com que as peças fiquem prontas 
também em ordem aleatória. Assim que a peça está pronta, o forno abre a sua porta 
automaticamente. O sinal de abertura da porta do forno (F1, F2 ou F3) é utilizado como o 
sinal de início do trabalho do manipulador. O projeto do comando seqüencial do 
manipulador leva em conta que esse sinal permanece até o momento em que a peça é 
retirada do forno. O detalhamento do funcionamento dos fornos, da sua alimentação e dos 
comandos de abertura e fechamento das suas portas não faz parte da solução deste 
exemplo. Em suma: assim que algum forno der o sinal de peça pronta, disponível, o 
manipulador deverá ir buscá-la e posicioná-la na forja. Após depositar a peça na forja, o 
manipulador aguarda em sua posição de repouso, até que fique pronta um nova peça em 
qualquer um dos três fornos. Conforme mostra a Figura 5, essa posição de repouso 
corresponde a uma posição de recuo de todos os atuadores. Todos eles são comandados 
por válvulas de simples solenóide, com exceção do atuador giratório D, cuja válvula 
possui duplo solenóide.