Programação aplicada de computadores

1. Programação aplicada de computadores Profa. Andréa Maria PedrosaValli www.inf.ufes.br/~avalli 2012/1 – EngenhariaElétrica

2. Objetivo da Disciplina: • Proporcionar uma visão geral sobre os conceitos definidos em programação orientada a objetos através do aprendizado da linguagem C++.  • Conteúdo: • Introdução • Princípios da Programação Estruturada • Classes e Objetos • Composição e Herança  • Polimorfismo • Exceções • Livro Texto: • H.M. Deitel e P.J. Deitel, C++: como Programar, 5 ed., Bookman, 2006.

3. Avaliação: Através de exercícios computacionais (Exerc) e provas escritas (PrEscr). A média parcial final é calculada da seguinte forma: 0.5 * Exerc * Entrevista + 0.5 * PrEscr, onde cada um dos termos corresponde a média aritmética dos exercícios e provas respectivamente. A nota da entrevista varia entre 0 e 1 e Exerc = 0.2 * Lista + 0.8 * Trabalho. A Segunda Chamada é para quem faltou alguma prova e justificou (essa prova pode ser escrita ou aplicada no computador). Homepage da Disciplina: www.inf.ufes.br/~avalli/programacao/paginas/prog_eletrica012.html

4. Introdução: Panorâmicadaprogramaçãoorientada a objetos • Referência: • Antonio Mendes da Silva Filho, Introdução à ProgramaçãoOrientada a Objetos com C++, Rio de Janeiro: Elsevier, 2010. • Objetivos: • Entender o porquê do surgimento do paradigma de programaçãoorientada a objetos (PPO). • Contextualizar as diferenças entre programaçãoorientada a objetos e a programaçãoestruturada. • Apresentar as principaiscaracterísticas das linguagens de programaçãoorientada a objetos. • Discutir as principaisdiferenças entre as linguagens C e C++. • Linguagens: C++,C#, Object Pascal, Java, Python, SmallTalk, Matlab

5. Cadaprogramaconsisteem um conjuntoorganizado de instruçõesqueoperamsobre um conjunto de dados, processando-os, a fim de realizaralgumafuncionalidade e produzirumasaída. • Obs: • A medidaqueossistemascrescem, cresce a complexidadeassociada a eles. • Antes da POO, o programador era ensinado a raciocinarsobreosproblemasemtermos de blocos de códicos (funções) ouprocedimentos e sobre a forma comoessesblocosatuavamsobreos dados (linguagensprocedimentais). • A POO é umalinguagem de programaçãoquefoicriada, baseada no raciocínio de classificação e manipulação do ambienteemquevivemos.

6. LinguagensProcedimentais: Fortran, Pascal, C, Basic • Um programa em uma linguagem procedimental é uma lista de instruções organizada em termos de funções e módulos (um agrupamento de várias funções em uma entidade maior). • Dividir um programaemfunções e módulos é um dos fundamentosdaprogramaçãoestruturada e os dados constituem a essência de um sistema. • Questão: O queacontece com os dados no paradigma de programaçãoorientada a procedimentos? Acessível a qualquer função Variáveis globais Acessível apenas à função F1 Acessível apenas à função F2 Variáveis locais Variáveis locais Função F1 Função F2

7. Objeto Objeto dados dados dados Função-membro Função-membro Função-membro Função-membro Função-membro Função-membro Objeto • Características das linguagensorientadas a objetos • Encapsulamento de dados: Os dados e funçõessãoencapsuladosemumaentidade – o objeto. As funções de um objetoem C++ sãochamadasfunções-membros e oferecemumaúnica forma de acessoaos dados. Não se podeacessaros dados diretamente (ocultação dos dados).

8. Vantagens do encapsulamento de dados: • Uma grande vantagem do encapsulamento é que toda parte encapsulada pode ser modificada sem que os usuários da classe em questão sejam afetados. Ex: liquidificador • O encapsulamento protege o acesso direto (referência) aos atributos (variáveis) de uma instância (molde) fora da classe onde estes foram declarados (use get e set para retornar e modificar o valor do atributo de um objeto). • Encapsular atributos também auxilia a garantir que o estado e o comportamento de um objeto se mantenha coeso. Ex: semáforo • Obs: Em termos intuitivos, uma classe é vista como um "molde" que gera instâncias de um certo tipo, já objeto é algo que existe fisicamente moldado a partir desse molde.

9. Raciocínioemtermos de objetos: diz-se queosobjetossãomembros de classes. Ex: um fusca é um objetodaclasseAutomóveis. Duas Rodas Biclicletas Estrada Quatro Rodas Motocicletas Terra Trem Automóveis Ferroviário Caminhões Bonde Ônibus Metrô Navios Passageiros Aéreo Cargueiros Gerra Aviões Submarinos Marítimo Helicópteros Pesquisas Balões Pesca Barcos Transporte Combate Transporte

10. classe base A A A B B B classes derivadas D C E • Classe: umaclasse serve como um padrão, modelooutemplate. Elaespecificaquais dados e quaisfunçõesserãoincluídosnosobjetosdaquelaclasse. Definirumaclassenãocriaquaisquerobjetos, assimcomo a simples existência de um tipo de dados intnãocriaquaisquervariáveis. Umaclasse é, portanto, um conjunto de objetossimilares. • Herança: o princípio de herançaconsidera a divisão de umaclasseem subclasses quecompartilhamcaracterísticascomuns com a classedaqualela é derivada. • Reusabilidade:umavezqueumaclassetenhasidocriada, escrita e depurada, elapode ser usadaporoutrosprogramadoresemseusprogramas. Maisainda, o programadorpodeadicionar novas características a ela, semmodificá-la.

11. Criação de novostipos de dados:um dos benefícios dos objetos é queelesoferecemaoprogramadoruma forma conveniente de construirnovostipos de dados. Ex: trabalhar com coordenadasx e y e operaçõesaritméticasnormais do tipoposicao1 = posicao2 + origem, onde as variáveisposicao1, posicao2 e origemrepresentamcoordenadas. • Polimorfismo e Overloading (Sobrecarga): podemosdefinir novas operaçõesparaseremusadosemnovostipos de dados. No exemploacima, osoperadores = (igual) e + (soma) sãodefinidospeloprogramadorpara a classePosicao. Usaroperadoresoufunções de formasdiferentes, dependentes do queelesestãooperando, é denominadopolimorfismo. Quando um operadorexistente tem a capacidade de ser usadoemnovostipos de dados, diz-se queeleestásobrecarregado (overloaded). Overloading é um tipo de polimorfismo e mais um das características de C++. • Diferenças entre C e C++: C++ é umalinguagemderivada de C. Portanto, C++ retém a maioria das característicasdalinguagem C e oferecesuporte à maiorquantidade de estilos de programação, tornando-a maisversátil e flexível. Os elementosmaisimportantesadicionadosao C paracriar o C++ compreendem classes, objetos e a POO. Além disso, incluiumaabordagemmelhorada de entrada e saída (E/S) e nova forma paracomentários.

12. Introdução: Um passeio por C++ • O que é C++ segundo Bjarne Stroustrup (o criador de C++, A Linguagem de Programação C++, 3ed., Bookman): • é uma C melhor • suporta abstração de dados, • suporta programação orientada a objetos e • suporta programação genérica. • Objetivo desta introdução: • Fornecer uma visão geral de C++ e as principais técnicas para usá-la mas omitindo os detalhes da programação. Concentre-se em técnicas de programação e não em recursos de linguagem.

13. Conteúdo Paradigmas de programação Programação orientada a procedimentos Programação modular Abstração de dados Programação orientada a objetos Programação genérica

14. 1. Paradigmas de programação • Programação orientada a objetos é uma técnica de programação - uma paradigma para escrever “bons” programas para um conjunto de problemas. A linguagem fornece bons mecanismo de suporte ao estilo de programação orientada a objetos. • Uma linguagem suporta um estilo de programação se ela fornece facilidades que tornem conveniente (razoavelmente fácil, seguro e eficiente) usar aquele estilo. • Uma linguagem não é necessariamente melhor que uma outra porque ela possui um recurso que a outra não tem, mas se os recursos que ela tem são suficientes para suportar os estilos de programação desejados nas áreas de aplicações pretendidas.

15. Princípios(estética e lógica, minimalismo, “o quevocênãosabenãopodeferi-lo”): Todososrecursosdevem ser claros e elegantementeintegradosnaslinguagem; Deve ser possívelusarrecursoscombinados; Devehaverpoucorecursosespúrios e de propósito especial; A implementação de um recursonãodeveimporumasignificativasobrecarga a programasquenãoexigemseuuso; Um usuárionecessita saber apenas o subconjuntodalinguagemexplicitamenteusadoparaescrever um programa. C++ foiprojetadaparasuportarabstração de dados, programaçãoorientada a objetos e programaçãogenéricaadicionalmente a técnicas de programaçãotradicional de C.

16. 2. Programaçãoorientada a procedimentos • Paradigma: • Decida quais procedimentos você quer; use os melhores algoritmos que você puder encontrar. • O foco é no procedimento – o algoritmo necessário para executar a computação desejada. A linguagem possui facilidades para passar/retornar argumentos para funções. • Recursos para expressar computações: • variáveis e aritmética • testes e laços • ponteiros e arrays

17. #include <iostream> • #include <cmath> • using namespace std; • const double PI = 3.14159; // define global constant PI • // calculates volume of a sphere • inline double sphereVolume( const double radius ) • { • return 4.0 / 3.0 * PI * pow( radius, 3 ); • } // end inline function sphereVolume • int main() • { • double radiusValue; • // prompt user for radius • cout << "Enter the length of the radius of your sphere: "; • cin >> radiusValue; // input radius • // use radiusValue to calculate volume of sphere and display result • cout << "Volume of sphere with radius " << radiusValue • << " is " << sphereVolume( radiusValue ) << endl; • return 0; // indicates successful termination • } // end main 

18. 3. Programação modular Com os anos, o enfoque mudou para a organização dos dados. Quando não existem agrupamentos de procedimentos com dados relacionados, a programação orientada a procedimentos é suficiente. Um conjunto de procedimentos relacionados com os dados que eles manipulam é denonimado módulo. Paradigma: Decida quais módulos você quer; particione o programa de modo a esconder os dados dentro dos módulos (o princípio da ocultação de dados). Exemplo de um módulo: uma pilha

19. namespace Pilha { // interface • void empilha( char ); -----> arquivo pilha.h • char desempilha( ); • } • # include “pilha.h” • void f( ) • { • Pilha::empilha(‘c’); • if( Pilha::desempilha( ) != ‘c’ ) error( “impossivel” ); -----> arquivo usuario.c • } • #include “pilha.h” • namespace Pilha { // implemetacao • const int tamanho_max = 200; ); -----> arquivo pilha.c • char v[tamanho_max]; • int topo = 0; • void empilha( char c ) { /* testa transbordamento e empilha c */} • void desempilha( ) { /* testa esvaziamento e desempilha */ } • } • Na definição da pilha devemos: • fornecer uma interface com o usuário para a pilha; • assegurar que a representação da pilha possa ser acessada somente através de sua interface com o usuário; • assegurar que a pilha seja inicializada antes de ser usada pela primeira vez.

20. Compilaçãoseparada: C++ suporta a noção de compilaçãoseparada de C, ouseja, pode ser usadoparaorganizar um programacomo um conjunto de trechos semi-independentes.

21. Tratamento de exceções: • À medidaqueosprogramascrescem e bibliotecassãoextensivamenteusadas, padrõesparatratamento de erros (ou, de modomaisgeral, “circunstânciasespeciais”) se tornamimportantes. • namespace Pilha { // interface • void empilha ( char ); • char desempilha ( ); • class Transbordou { }; // tiporepresentandoexcecoes de transbordamento • } • void Pilha::empilhar( char c ) • { • if ( topo == tamanho_max ) throw Transbordou( ); • // empilha c • } • void f( ) { • // . . . • try { // excecoesquesaotratadaspelotratadordefinidoabaixo • while ( true ) Pilha::empilha ( ‘c’ ); • } • catch ( Pilha::Transbordou ) { • // oops: transbordamento de pilhas; tome a acaoapropriada • } • // . . . • }

22. 4. Abstração de dados • C++ permiteque o usuáriodefinadiretamentetiposque se comportam (aproximadamente) do mesmomodoqueostiposprimitivos. • Paradigma: • Decidaquaistiposvocêquer; providencie um conjuntocompleto de operaçõesparacadatipo. • Podemosterporexemplo: • definição de tiposemmódulos- Ex: namespacePilha com struct • tiposdefinidospelousuário- Ex: classe de númerocomplexos • tiposconcretos- Ex: classPilha • tiposabstratos (a interface isolamaiscompletamente um usuário dos detalhes de implementação) – Ex: classPilha • funçõesvirtuais – tabela de funçõesvirtuais

23. 1. Definição de tiposemmódulos • Exemplo: definir um gerenciador de pilhas • namespace Pilha { • struct Rep; // definicao do layout dapilhaest’aemalgumlugar • typedef Rep& pilha; • pilhacria ( ); // fazeruma nova pilha • void destroi ( pilha s ); // destruir s • void empilha ( pilha s, char c ); // inserir c em s • char desempilha ( pilha s ); // desempilhaem s • } • Uso: • structError_desempilha{ }; • void f ( ) • { • Pilha::pilha s1 = Pilha::cria ( ); // fazeruma nova pilha • Pilha::pilha s2 = Pilha::cria ( ); // fazerumaoutra nova pilha • Pilha::empilha ( s1, ‘c’ ); • Pilha::empilha ( s2, ‘k’ ); • if ( Pilha::desempilha ( s1 ) != ‘c’ ) throw Desempilha_mal ( ); • if ( Pilha::desempilha ( s2 ) != ‘k’ ) throw Desempilha_mal ( ); • Pilha::destroi ( s1 ); • Pilha::destroi ( s2 ); • }

24. 2. Tiposdefinidospelousuário:númeroscomplexos é um exemplo • class complex { • double re, im; • public: • complex ( double r, double I ) { re = r; im = I; } // constroicomplexo a partir de doisescalares • complex ( double r ) { re = r, im = 0; } // constroicomplexo a partir de um escalar • complex ( ) { re = im = 0; } // constroi default (0,0) • friend complex operator+ ( complex, complex ); • friend complex operator- ( complex, complex ); // binario • friend complex operator- ( complex ); // unario • friend complex operator* ( complex, complex ); • friend complex operator/ ( complex, complex ); • friend bool operator== ( complex, complex ); // igual • friend bool operator!= ( complex, complex ); // diferente • // . . . • }; • complex operator+ ( complex a1, complex a2 ) { return complex ( a1.re + a2.re, a1.im + a2.im ); } • void f ( complex z ) { • complex a = 2.3; • complex b = 1/a; • complex c = a + b*complex(1,2.3); • // … • if ( c!= b ) c = - (b/a) + 2*b; • // . . . • }

25. 3. Tiposconcretos: comoexemplo, considere um tipoPilhadefinidopelousuáriodaseguinte forma: • class Pilha { • char* v; • inttopo; • inttamanho_max; • public: • Pilha ( int s ) // construtor • ~Pilha ( ) // destruidor • class Transbordou { }; // usadacomoexcecao • class Esvaziou { }; // usadacomoexcecao • class Erro_tamanho { }; // usadacomoexcecao • void empilha ( char c ); • char desempilha ( ); • }; • Uso: • Pilha s_var1 ( 10 ); // pilha global com 10 elementos • void f ( Pilha& s_ref, inti ) { // referencia a Pilha • Pilha s_var2 ( i ); // pilha local com ielementos • Pilha* s_ptr = new Pilha ( 20 ); // ponteiroparaPilhaalocadanamemorialivre • s_var1.empilha ( ‘a’ ); • s_var2.empilha ( ‘b’ ); • s_ref.empilha ( ‘c’ ); • s_ptr->empilha ( ‘d’ ); • // . . .

26. 4. Tiposabstratos: Ex: umapilhadefinidacomo um tipoabstrato de dados. • class Pilha { • public: • class Transbordou { }; // usadacomoexcecao • class Esvaziou { }; // usadacomoexcecao • virtual void empilha ( char c ) = 0; • virtual char desempilha ( ) = 0; • }; • Uso: • void f( Pilha& s_ref ) • { • s_ref.empilha ( ‘c’ ); • if ( s_ref.desempilha ( ) != ‘c’ ) throw Erro_desempilha ( ) ; • } • A palavravirtualsignificaem C++ “quepode ser redefinidaposteriormenteemumaclassederivada a partirdesta”. A classederivada de Pilhaforneceumaimplementaçãopara a interface de Pilha e a sintaxe= 0indicaquealgumaclassederivada de Pilhadevedefinirestafunção. Desta forma, estaPilhapodeservircomouma interface paraqualquerclassequetenhaumaimplementação das funçõesempilha() e desempilha(). É um tipopolimórfico, ouseja, fornece a interface paradiversasoutras classes.

27. Implementações: • class Array_pilha : public Pilha { // Array_pilhaimplementaPilha • char* p; • inttopo; • inttamanho_max; • public: • Array_pilha ( int s ); • ~Array_pilha ( ); • void empilha ( char c ) ; • char desempilha ( ) ; • }; • class Lista_pilha : public Pilha { // Lista_pilhaimplementaPilha • list<char> lc; • public: • Lista_pilha ( ) { } • void empilha ( char c ) { lc.push_front ( c ); } • // . . . • Uso: • void g ( ) { • Array_pilha as( 200 ); • f( as ); • }; • void h ( ) { • Lista_pilhals; • f( ls ); • };

28. 5. Funçõesvirtuais: • void f( Pilha& s_ref ) • { • s_ref.empilha ( ‘c’ ); • if ( s_ref.desempilha ( ) != ‘c’ ) throw Erro_desempilha ( ) ; • } • Como pode a chamadas_ref.empilha ( ) ser resolvidaemrelação à definiçãodafunçãocerta? • Quandof() é chamadaemg(), Array_pilha::empilha()deve ser chamada. Quandof() é chamadaemh(), Lista_pilha::empilha()deve ser chamada. • Tabela de funçõesvirtuais (vtbl):

29. 5. Programaçãoorientada a objetos • Paradigma: • Decidaquaistiposvocêquer; providencie um conjuntocompleto de operaçõesparacadaclasse; explicite as coisasemcomumatravés do uso de herança. • Ex: problemas com tiposconcretos • class Ponto { /* . . . */ } • class Cor { /* . . . */ } • enumTipo { circulo, triangulo, quadrado }; • class Forma { • Tipo k; // campo de tipo • Ponto centro; • Cor co; • // . . . • public: • void desenha ( ); • void rotacao ( int ); • // . . . • };

30. void Forma::desenha ( ) { • switch ( k ): • case circulo: • // desenha um circulo • break; • case triangulo: • // desenha um circulo • break; • case quadrado: • // desenha um circulo • break; • } • } • Hierarquia de classes • class Forma { • Ponto centro; • Cor co; • // . . . • public: • Ponto onde ( ) { return centro; } • void move ( Ponto to ) { centro = to; /* . . . */ desenha ( ); } • virtual void desenha ( ) = 0; • virtual void rotacao ( int angulo ) = 0; • // . . . • };

31. Para definiruma forma particular, precisamosdizerque é umaForma e especificarsuaspropriedadesparticulares (incluindo as funçõesvirtuais): • class Circulo : public Forma { // classederivadadaclasse base Forma • intraio; • public: • void desenha ( ) { /* . . . */ } • void rotacao ( int ) { } // a funcaonula ; • }; • Diz-se que a classederivadaherdamembros de suaclasse base, de forma que o uso das classes base e derivadas é habitualmentechamado de herança. • Encontrar a quantidade de propriedadesemcomum entre tiposquepossam ser exploradosusando-se herança e funçõesvirtuaisnão é um processo trivial naescrita de um projetoem POO. • O projetistaexperienteaplicadiversosparadigmas, de acordo com as necessidades.

32. 6. Programaçãogenérica • Paradigma: • Decidaquealgoritmosvocêquer; parametrize-os de forma queelesfuncionemparadiversostipos e estruturas de dados desejados. • Ex: umapilha de qualquercoisa, substituindo o tipoespecíficocharpor um parâmetro de gabarito: • template<class T> class Pilha { • T* v; • inttamanho_max; • inttopo; • public: • Pilha ( int s ); // constutor • ~Pilha ( ); // destruidor • class Esvaziou { }; • class Transportou { }; • void empilha ( T ); • T desempilha ( ); • };

33. As funçõesmembropodem ser definidas de forma similar: • template<class T> void Pilha<T>::empilha( T c ) • { • If ( topo == tamanho_max ) throw Transbordou ( ); • v[topo] = c; • topo = topo + 1; • } • template<class T> T Pilha<T>::desempilha( ) • { • If ( topo == 0 ) throw Esvaziou ( ); • topo = topo - 1; • return v[topo]; • } • Uso: • Pilha<char> sc( 200 ); // pilha de 200 caracteres • Pilha<complex> scplx ( 30 ); // pilha de 30 numeroscomplexos • Pilha< list<int> > sli ( 45 ); // pilha de 45 listas de inteiros • void f ( ) • { • sc.empilha ( ‘c’ ); • if ( sc.desempilha ( ) != ‘c’ ) throw Erro_desempilha ( ); • scplx.empilha ( complex ( 1, 2 ) ); • If ( scplx.desempilha ( ) != complex( 1, 2 ) ) throw Erro_desempilha ( ); • }

34. Similarmente, podemosdefinirlistas, vetores, etc., comogabaritos. Gabaritossão um mecanismo de tempo de compilação, de modoqueseuusonãoimplicaemnenhumasobrecargaem tempo de execuçãoquandocomparado com “com códigoescrito a mão”. • Umaclassecontendoumacoleção de elementos de algumtipo é habitualmentechamada de contêinerousimplementecontêiner. A bibliotecapadrão C++ ofereceumavariedade de contêineres e osusuáriospodemescreverseuspróprioscontêineres. • Conselhos dados peloautor, BjarneStroustrup: • Não se assuste! Tudo se tornaráclaro a tempo; • Vocênãoprecisaconhecercadadetalhe de C++ paraescreverbonsprogramas; • Concentre-se emtécnicas de programação e nãoemrecursosdalinguagem.