Apost PLP Aluno

Teoria de Linguagens
1 LINGUAGENS DE PROGRAMAO : INTRODUO E HISTRICO......................5 1.1 DEFINIO..................................................................................................................................5 1.2 PORQUE ESTUDAR LP ?................................................................................................................5 1.3 HISTRICO..................................................................................................................................5 1.3.1 FORTRAN (FORMULA TRANSLATION)..................................................................................6 1.3.2 COBOL (COMMON BUSINESS ORIENTED LANGUAGE)..................................................................7 1.3.3 ALGOL 60 (ALGORITHMIC ORIENTED LANGUAGE)....................................................................7 1.3.4 LISP (LIST PROCESSING)..........................................................................................................7 1.3.5 APL (A PROGRAMMING LANGUAGE)...........................................................................................8 1.3.6 BASIC (BEGINNERS ALL-PURPOSE SYMBOLIC INSTRUCTION CODE)...............................................8 1.3.7 PL/I (PROGRAMMING LANGUAGE I).............................................................................................9 1.3.8 SIMULA 67...........................................................................................................................9 1.3.9 ALGOL 68.............................................................................................................................9 1.3.10 PASCAL............................................................................................................................10 1.3.11 PROLOG (PROGRAMMING IN LOGIC).................................................................................10 1.3.12 SMALL TALK..................................................................................................................10 1.3.13 C........................................................................................................................................10 1.3.14 MDULA 2.......................................................................................................................11 1.3.15 ADA..................................................................................................................................11 1.4 EVOLUO DOS CONCEITOS EM LINGUAGENS................................................................................11 2 CARACTERISTICAS GERAIS DE UMA LINGUAGENS DE PROGRAMAO.......15 2.1 ESPECIFICAO DE UMA LP........................................................................................................15 2.1.3 SINTAXE DE UMA LP................................................................................................................16 2.1.4 SEMNTICA DE LP...................................................................................................................19 2.2 TRADUO DE UMA LP..............................................................................................................19 2.2.3 INTERPRETAO.......................................................................................................................19 2.2.4 COMPILAO...........................................................................................................................19 2.3 CARACTERSTICAS DE DESIGN DE LP...........................................................................................21 2.4 ESCOLHA DE UMA LP.................................................................................................................22 3 PARADIGMAS DE LP.........................................................................................................23 3.1 PARADIGMA IMPERATIVO DE LP..................................................................................................23 3.1.1 BINDING.................................................................................................................................23 3.1.1.1 "INFORMATION BINDING" ......................................................................................................23 3.1.1.2 ESCOPO DE BINDING E UNIDADES DE EXECUO.......................................................................25 3.1.1.3 ESCOPO DE BINDING DE NOME...............................................................................................26 3.1.1.4 ESCOPO DE BINDING DE LOCAO..........................................................................................28 3.1.1.5 EXERCCIOS .........................................................................................................................30 3.2 PARADIGMA DECLARATIVO..........................................................................................................30 3.2.3 PROGRAMAO LGICA............................................................................................................30 3.2.4 O PARADIGMA FUNCIONAL DE LP............................................................................................31 3.2.4.1 PARADIGMA FUNCIONAL........................................................................................................31
Criado por Marcelo Fernandes dos Santos
1.3. O PARADIGMA ORIENTADO A OBJETO (OO) DE LP....................................................................32 4 ORGANIZAO DE DADOS.............................................................................................34 4.1 TIPOS DE DADOS.........................................................................................................................34 4.2 TIPOS EMBUTIDOS DE DADOS......................................................................................................34 4.3 TIPOS AGREGADOS DE DADOS.....................................................................................................34 4.3.1 PRODUTO CARTESIANO.............................................................................................................34 4.3.2 MAPEAMENTO FINITO...............................................................................................................34 4.3.3 SEQNCIAS............................................................................................................................35 4.3.4 RECURSO..............................................................................................................................35 4.3.5 UNIO DISCRIMINADA..............................................................................................................35 4.4 TIPOS DEFINIDOS PELO USURIO................................................................................................35 4.5 CONVERSO DE TIPOS................................................................................................................36 4.6 REAS PROBLEMTICAS..............................................................................................................36 4.6.1 TIPAGEM FORTE......................................................................................................................36 4.6.2 COMPATIBILIDADE DE TIPOS......................................................................................................37 4.6.3 PONTEIROS..............................................................................................................................37 5 ESTRUTURAS DE CONTROLE........................................................................................37 5.1 NVEL DE COMANDO..................................................................................................................37 5.1.1 CONTROLE SEQENCIAL............................................................................................................37 5.1.2 CONTROLE DE SELEO............................................................................................................38 5.1.3 CONTROLE DE REPETIO.........................................................................................................38 5.1.4 ESTRUTURAS DE CONTROLE DEFINIDAS PELO PROGRAMADOR.........................................................38 5.2 ESTRUTURA DE CONTROLE A NVEL DE UNIDADE..........................................................................39 5.2.3 UNIDADES SUBORDINADAS CHAMADAS EXPLICITAMENTE...............................................................39 5.2.3.1 DADOS COMO PARMETROS...................................................................................................39 5.2.3.2 SUB-PROGRAMAS COMO PARMETROS.....................................................................................40 6 INTRODUO AO PARADIGMA FUNCIONAL...........................................................40 6.1 HISTRIA DA PROGRAMAO FUNCIONAL.....................................................................................40 6.2 LINGUAGENS DE PROGRAMAO FUNCIONAL (P.F.)...................................................................41 6.3 DEFINIO DE FUNO............................................................................................................43 6.4 CONCEITO DE PROGRAMAO FUNCIONAL...................................................................................44 6.5 REDUO DE EXPRESSO............................................................................................................44 7 INTRODUO LINGUAGEM SCHEME.....................................................................45 7.1 SOBRE A LINGUAGEM...............................................................................................................45 7.2 SINTAXE DA LINGUAGEM.............................................................................................................45 7.3 NMEROS..................................................................................................................................46 7.4 STRING.....................................................................................................................................47 7.5 SEQNCIAS...............................................................................................................................47 7.6 FUNES FINITAS.......................................................................................................................47 7.7 FORMAS FUNCIONAIS..................................................................................................................47
8 DESENVOLVIMENTO DE FUNES BSICAS EM SCHEME..................................48 8.1 CONSTANTES E FUNES SIMPLES:................................................................................................48 8.2 ALGORITMOS RECURSIVOS..........................................................................................................49 8.3 MANIPULAO DE LISTAS EM SCHEME.......................................................................................50 8.4 USANDO A NOTAO LAMBDA..................................................................................................51 EXERCCIOS....................................................................................................................................51 RECURSIVO ...................................................................................................................................53 9 INTRODUO PROGRAMAO ORIENTADA A OBJETOS................................54 9.1 CONCEITOS BSICOS..................................................................................................................55 9.2 CARACTERSTICAS IMPORTANTES DE P.O.O.................................................................................55 10 INTRODUO LINGUAGEM SMALLTALK..........................................................58 10.1 OBJETOS EM SMT..................................................................................................................58 9.1.1 O QUE UM OBJETO EM SMT...................................................................................................58 10.1.3 ENCAPSULAMENTO INFORMAES.............................................................................................59 10.1.4 OBJETOS LITERAIS.................................................................................................................60 10.2 MENSAGENS............................................................................................................................60 9.2.1 MENSAGENS UNRIAS..............................................................................................................61 10.2.3 MENSAGENS KEYWORD..........................................................................................................61 10.2.4 MENSAGENS BINRIAS...........................................................................................................61 10.2.5 OUTROS TIPOS DE MENSAGENS................................................................................................61 10.2.5.1 MENSAGENS ARITMTICAS...................................................................................................61 10.2.5.2 MENSAGENS DENTRO DE MENSAGENS...................................................................................62 10.2.5.3 MENSAGENS EM CASCATA....................................................................................................62 10.2.6 VARIVEIS TEMPORRIAS........................................................................................................63 10.2.7 SINTAXE DAS PRINCIPAIS MENSAGENS........................................................................................63 10.2.8 ITERADORES..........................................................................................................................64 10.3 IMPLEMENTAO DE CLASSES E MTODOS.................................................................................66 9.3.1 CLASSES.................................................................................................................................66 10.3.3 MTODOS.............................................................................................................................67 10.3.4 CLASS HERARCHY BRAUSER...................................................................................................67 CLASS HIERACHY BROWSER............................................................................................................68 10.3.5 A VARIVEL ESPECIAL SELF ................................................................................................68 10.3.6 CRIAO DE NOVOS OBJETOS E O OBJETO ESPECIAL NIL.............................................................68 10.3.7 VARIVEIS DE INSTNCIA........................................................................................................69 10.3.8 RECURSO............................................................................................................................69 10.3.9 CRIAO DE CLASSES COMPLETAS.............................................................................................70 10.4 DESCRIO DA CLASSE COLLECTION.........................................................................................70 11 PROBLEMA PROPOSTO.................................................................................................72 MTODOS DE INSTNCIA DE BRICK.................................................................................................72 MTODOS DE CLASSES DE MOVIGCOMP.........................................................................................72 MTODOS INSTNCIA DA CLASSES MOVIGCOMP.............................................................................72
1 PROGRAMAO ORIENTADO A OBJETO....................................................................1 1.1 ENCAPSULAMENTO........................................................................................................................2 1.2 OCULTAMENTO DE INFORMAO E DE IMPLEMENTAO...................................................................2 1.3 RETENO DE ESTADO.................................................................................................................3 1.4 IDENTIDADE DE OBJETO................................................................................................................3 1.5 MENSAGENS................................................................................................................................5 1.5.1 ESTRUTURA DE UMA MENSAGEM .................................................................................................5 1.5.3 ARGUMENTOS DE UMA MENSAGEM...............................................................................................5 1.5.4 OS PAPIS DOS OBJETOS NAS MENSAGENS....................................................................................7 1.5.5 TIPOS DE MENSAGEM.................................................................................................................7 1.6 CLASSES......................................................................................................................................8 1.7 HERANA....................................................................................................................................9 1.8 POLIMORFISMO..........................................................................................................................10 1.9 GENERICIDADE...........................................................................................................................13
1 Linguagens de Programao : Introduo e Histrico

1.1 Definio
Uma LP (Linguagem de Programao) uma linguagem destinada a ser usada por uma pessoa para expressar um processo atravs do qual um computador pode resolver um problema. Os quatro modelos de LP correspondem aos pontos de vista dos quatro componentes citados. A eficincia na construo e execuo de programas depende da combinao dos quatro pontos de vista. 1.2 Porque estudar LP ?
1. Maior habilidade em resolver problemas: uma maior compreenso de uma LP pode aumentar nossa habilidade em pensar em como atacar os problemas. Tanto melhor se dominarmos os vrios modelos de LP. 2. Melhor uso de uma LP: compreenso das funes e implementao das estruturas de uma LP nos levam a usar a LP de modo a extrair o mximo de sua funcionalidade e eficincia. 3. Melhor escolha de uma LP: adequao ao problema. 4. Maior facilidade em aprender novas LPs: conceitos chaves comuns s LPs. 5. Melhor designer de LPs: linguagens de interfaces de sistemas, extenso de LP via operadores e tipos de dados. 1.3 Histrico Genealogia das Linguagens de Programao Ano Originador Linguagens Finalidade Pretendida Predecessora s 1952-57 J. Backus ------Computao numrica. (IBM) 1958-60 Comit FORTRAN Computao numrica. 1959-60 Comit ------Proc. dados comercial. 1956-60 K. Iverson ------Proc. de Vetores. (Harvard) 1956-62 J. McCarthy ------Computao (MIT) Simblica. 1962-66 R. Griswold ------Proc. de seqncias. (Bell Labs) 1971 N. Wirth Algol60 Propsito geral de
5
Linguagem FORTRAN Algol60 COBOL APL LISP SNOBOL PASCAL
(ETH Zurich) C Modula Ada 1974 1977 1979 D. Ritchie (Bell Labs) N. Wirth (ETH Zurich) J. Ichbah et al. (CII Honeywell Bull) Algol68 BCPL Pascal Pascal Simula67
ensino e suportar programao . Programao de Sistemas. Programao de sistemas em tempo real. Aplicaes de componentes em tempo real.
O processo de desenvolvimento de programas originalmente consistia s em fase de codificao. No incio da computao, o computador era utilizado principalmente em aplicaes cientficas, cada aplicao sendo programada por uma pessoa. Uma linguagem de programao precisava suportar apenas um programador trabalhando. O que, seria pelos padres atuais, uma aplicao extremamente simples. O desejo de usar o computador em cada vez mais aplicaes levou a sua utilizao em ambientes mais sofisticados e menos bem compreendidos. Isto, por sua vez, levou a necessidade de equipes de programadores e de abordagens mais formais. Assim, o que era antigamente efetuado por um programador, requer atualmente o trabalho de uma equipe. E para aproveitar trabalhos j desenvolvidos no passado a manuteno se tornou uma questo importante. A confiabilidade de sistema se tornou muito importante devido a dois fatores: primeiro, por que os usurios esto cada vez com menos experincia. O Segundo fator que sistemas computacionais esto sendo aplicados em reas de risco, onde no podem haver erros . As deficincias de linguagens de programao tem levado a grandes esforos em projetos de linguagens a fim de alcanarem objetivos ideais. 1.3.1 FORTRAN (FORmula TRANslation) A linguagem Fortran, desenvolvida em 1956 por John Backus, foi proposta visando a resoluo de problemas cientficos, para isto utilizando a notao algbrica. Foi desenvolvida, inicialmente para uma mquina especfica, o IBM 704. , ainda hoje, uma linguagem muito utilizada no meio tcnico-cientfico, tendo sido aprimorada ao longo do tempo, constituindo as diversas verses disponveis. Um dos motivos pelos quais o FORTRAN ainda muito utilizado a disponibilidade de uma vasta biblioteca de software contendo rotinas freqentemente utilizadas, tais como rotinas para clculo de funes trigonomtricas, equaes algbricas polinomiais, etc, o que permite uma reduo dos custos e tempo de desenvolvimento dos programas. Contribuies para futuras linguagens:
Criado por Marcelo Fernandes dos Santos 6
variveis comando de atribuio conceito de tipos modularidade (com o uso de subprogramas) E/S formatadas
1.3.2 COBOL (COmmon Business Oriented Language) A linguagem COBOL, desenvolvida em 1959 pelo Departamento de Defesa dos EUA e fabricantes de computadores , padro para as aplicaes comerciais e muito utilizada ainda hoje. Seu desenvolvimento se deu de forma independente da mquina. O cdigo "English-like" e excelente para a manipulao de arquivos. Contribuies de COBOL para futuras linguagens: cdigo mais legvel estrutura de dados heterognea (record)
1.3.3 ALGOL 60 (ALGorithmic Oriented Language) Linguagem algbrica de origem europia, desenvolvida pelo comit Internacional popular, destinada resoluo de problemas cientficos. Influenciou o projeto de quase todas as linguagens projetadas a partir de 1960. Descrita em BNF (Backus-Naur Form), foi projetada independente da implementao, o que permite uma maior criatividade, porm de implementao mais difcil. pouco usada em aplicaes comerciais devido ausncia de facilidades de E/S na descrio e pelo pouco interesse de vendedores. Alm disso, tornou-se padro para a publicao de algoritmos. Contribuies de ALGOL 60 para futuras linguagens: estrutura de blocos: habilidade de se criar blocos de comandos para o escopo de variveis e extenso de influncia de comandos de controle comandos de controle estruturados: if-then-else e uso de uma condio geral para controle de iterao recursividade: habilidade de um procedimento chamar a si prprio
1.3.4 LISP (LISt Processing) Linguagem funcional criada em 1960, por John McCartly do grupo de IA do MIT, para dar suporte pesquisa em Inteligncia Artificial. Foi inicialmente desenvolvida para o IBM 704. Existem muitos dialetos pois LISP nunca foi padronizada. Porm, em 1981 surgiu o Common LISP que um padro informal. Os programas em LISP so listas.
Contribuio de LISP para futuras linguagens: pioneira na idia de computao simblica ou nonumrica 1.3.5 APL (A Programming Language) Foi desenvolvida por volta de 1960 por Kenneth Iverson - Harvard, IBM. Utiliza notao matemtica, com operadores poderosos, possuindo muitos operadores e muitos caracteres o que gera grande dificuldade de implementao. Tem uma notao compacta e utilizada em aplicaes matemticas. Segue o modelo funcional e tem como principal estrutura de dados o ARRAY, com diversos operadores sobre esta estrutura.
1.3.6 BASIC (Beginners All-purpose Symbolic Instruction Code) A linguagem BASIC, desenvolvida em meados dos anos 60 por John Kemeny e Thomas Kurtz no Dartmouth College, teve como objetivo ensinar alunos de graduao a usarem um ambiente interativo de programao, atravs de uma LP de fcil aprendizado. Com o surgimento dos microcomputadores de baixo custo, no incio dos anos 70, o BASIC tornou-se muito popular, embora no tenha contribudo muito tecnologicamente. Contribuies de Basic para futuras linguagens: uma das primeiras LPs a prover um ambiente de programao interativo como parte da linguagem execuo interpretativa de programas
Exemplo de programa Basic Organizao de um programa BASIC: Um programa constitudo de uma seqncia de declaraes (instrues) que devem aparecer na ordem em que devero ser executadas, a menos que seja indicado um desvio. A seguir so apresentadas regras que se aplicam a todas as declaraes em BASIC: 1. Cada declarao deve aparecer em uma linha separada. 2. Uma declarao no pode possuir comprimento superior a um linha (em geral 80 caracteres). 3. Cada declarao deve ser iniciada com uma quantidade positiva inteira, conhecida como nmero da declarao (nmero da linha). Duas declaraes no podem possuir o mesmo nmero de identificao. 4. Declaraes sucessivas devem possuir nmeros de declaraes crescentes. 5. Os nmeros das declaraes devem ser seguidos de uma palavrachave do BASIC, que indicar o tipo de instruo a ser executado. 6. Espaos em branco podem ser inseridos, sempre que se desejar, para melhorar a leitura da declarao.
8
Obs: Cada linha em branco devem possuir um nico nmero de declarao seguido de um espao em branco. 1.3.7 PL/I (Programming Language I) Desenvolvida em meados dos anos 60 pela IBM com o objetivo de incorporar caractersticas das LPs existentes numa nica LP de propsito geral. Assim PL/I inclui: estrutura de bloco, de controle e recursividade do ALGOL 60; subprogramas e E/S formatadas do FORTRAN; manipulao de arquivos e registros do COBOL; alocao dinmica de memria e estruturas encadeadas do LISP; operaes de arrays do APL.
uma linguagem difcil de aprender e implementar devido a sua grande complexidade. Alm disso, faz uso de defaults. Contribuies de PL/I para futuras linguagens: tratamento de interrupo - execuo de procedimentos especficos quando uma condio excepcional ocorre multitarefa - especificao de tarefas que podem ser executadas concorrentemente
1.3.8 SIMULA 67 Linguagem baseada em Algol 60, criada no incio dos anos 60 por Ole Johan Dahl e Kristan Nygaard, na Noruega. destinada descrio de sistemas e programao de simulaes. Contribuio de SIMULA 67 para futuras linguagens: conceito de classe: Uma classe um encapsulamento de dados e procedimentos que podem ser instanciados em um conjunto de objetos. o conceito predecessor ao tipo abstrato de dados (ADA e Mdula 2) e das classes das linguagens orientadas a objeto (Smalltalk e C++)
1.3.9 ALGOL 68 muito diferente do Algol 60. Linguagem de propsito geral que foi projetada para a comunicao de algoritmos, para sua execuo eficiente em vrios computadores e para ajudar seu ensino a estudantes. Porm de difcil descrio, o que resultou em uma baixa popularidade. Contribuio de ALGOL 68 para futuras linguagens: ortogonalidade: uma LP que ortogonal tem um nmero de construtores bsicos e um conjunto de regras para
combin-los relativamente pequeno (oposto a PL/I) 1.3.10 PASCAL Desenvolvida por Niklaus Wirth em 1969, uma linguagem de fcil aprendizado e implementao, suporta programao estruturada e adequada para o ensino de programao. Em meados dos anos 80 tambm passou a ser usada para a programao em micro-computadores. Influenciou praticamente todas as linguagens mais recentes. Contribuies de Pascal para futuras linguagens: estruturas de controle flexveis tipos definidos pelo usurio arquivos records conjuntos
1.3.11 PROLOG (PROgramming in LOGic) Linguagem desenvolvida em 1972 em Marseille na Frana. destinada a aplicaes de Inteligncia Artificial e se baseia em lgica formal. a LP do projeto japons de quinta gerao.
1.3.12 SMALL TALK Criada por Alan Kay da Xerox - Palo Alto no incio dos anos 70. Apresenta um ambiente de programao com menus pop-up, windows e mouse (modelo para Apple Macintosh). Segue o modelo orientado a objetos, possuindo o conceito de classe do SIMULA 67 mais encapsulamento, herana e instanciao. Contribuies de SmallTalk para futuras linguagens: 1.3.13 C Desenvolvida pelo Bell Lab no incio dos anos 70, visando a implementao do UNIX. Possui um padro feito por Kernighan e Ritchie em 1978. Tem facilidades para a programao em "baixo nvel" e gera cdigo eficiente. Possui um grande conjunto de operadores, o que permite um cdigo compacto, porm de baixa legibilidade. excelente para construir programas portveis. primeira LP a utilizar o paradigma de programao interativa introduz o conceito de LP extensvel
10
1.3.14 MDULA 2 Criada por Niklaus Wirth no final dos anos 70, uma linguagem de propsito geral, baseada em melhorias no Pascal. boa para projetos de desenvolvimento de software de grande porte. Alm disso foi usada para ensinar programao. Mdula 2 elaborou Pascal em: mdulos podem ser usados para implementar TAD (Tipos Abstratos de Dados) todas as estruturas de controle tm uma palavra-chave de terminao co-rotinas - execuo intercalada tipos de procedimentos
1.3.15 ADA Foi desenvolvida no incio dos anos 70 pelo Departamento de Defesa dos Estados Unidos. dedicada aos "embedded systems" (operam como parte de um sistema maior) e se baseia no Pascal. Teve um padro em 1983. Alm disso, usa conceitos de classe do Simula 67, adota o tratamento de excees de PL/I e prov facilidades para processamento concorrente. Foi projetada para apoiar aplicaes numricas, programao de sistemas e aplicaes que envolvem consideraes de tempo real e concorrncia. Seu nome se deve a ADA Augusta, 1a programadora, colaboradora de Charles Babbage - sculo 19.
1.4
Evoluo dos Conceitos em Linguagens
Linguagens de programao podem favorecer a adoo de metodologias de projetos sistemticos de programas, por outro lado, a linguagem tem forte influencia na confiabilidade, legibilidade e modificabilidade dos programas. Regras e metodologias que so teis no desenvolvimento de sistemas (programas) confiveis e de alta qualidade podem ser, e esto sendo cada vez mais, incorporados nas linguagens de programao a fim de encorajar os usurios a aplicarem estas metodologias ou, pelo menos, para facilitar sua aplicao. O propsito desta seo apresentar as idias importantes que tm influenciado a evoluo dos projetos de linguagens, tais como: - Conceito de abstrao De dados De controle - Conceito de correo de programas - Influncia da linguagem na programao de grande porte. a) O Papel da Abstrao
11
Computadores esto substituindo pessoas em muitas aplicaes, desde administrativas at controle de processos. Para substituir o procedimento manual, os analistas de sistemas precisam reproduzir seu comportamento em um programa de computador. Os programas de computador podem ser idealizados como modelos destes procedimentos manuais. Como qualquer modelo, um programa de computador uma abstrao da realidade. Abstrao o processo de identificar as qualidades ou propriedades importantes de fenmeno a ser modelado. Usando o modelo abstrato, pode-se concentrar unicamente nas qualidades ou propriedades relevantes e ignorar as irrelevantes. O que relevante depende da finalidade para a qual a abstrao est sendo projetada. Sub-programas e macros tambm foram introduzidos pelas linguagens de montagem como um meio de o programador nomear uma atividade descrita por um grupo de aes, e consider-las como uma nica ao Sub-programas so ferramentas teis para a programao metdica, pois so mecanismos para construir abstraes. Um sub-programa implementao de uma abstrao, enquanto uma chamada do sub-programa representa o uso da abstrao. Abstraes de dados modelam os dados manipulados pelos programas combinando aes elementares em formas de complexidade arbitrria. a.i) Abstraes de Dados a.i.i) Nas Primeiras Linguagens Linguagens a nvel de mquina encaram os dados armazenados como seqncias de bits que podem ser manipulados pelas instrues de mquina. Os primeiros passos rumo as abstraes de dados foram dados pelas linguagens FORTRAN, COBOL e Algol60. Nestas linguagens as informaes so armazenadas em posies de memria (inteiros, reais, lgicos, ...) e no como bits annimos. A deciso sobre quais abstraes de dados incluir em uma linguagem de programao foi ditada principalmente pelas mquinas para as quais a linguagem era destinada e pelo espectro de aplicaes que pretendia-se que a linguagem cobrisse. Como resultado, nenhuma linguagem acaba sendo apropriada para todas as aplicaes, j que o programador fica limitado pelo poder expressivo do conjunto fixo de abstraes fornecida pela linguagem. a.i.ii) Nas Linguagens Modernas O caminho seguido pelas linguagens de gerao mais modernas , em certo sentido menos ambicioso, mas tem mostrado ser mais efetivo. Elas tentam atingir generalidade, no fornecendo um conjunto exaustivo de abstraes embutidas, mas sim provendo mecanismos flexveis e fceis de usar, pelos quais, o programador pode definir novas abstraes. As abstraes identificadas para o projeto do sistema ficam refletidas, pelo menos em algum grau, pela estrutura resultante do programa. Como
12
conseqncia, os programas ficam mais fceis de serem entendidos e modificados e tm maior probabilidade de estarem corretos. Em um aspecto importante, contudo, abstraes embutidas e definidas pelo usurio se diferenciam. Embutidas escondem do programador a representao subjacente, a qual no pode ser manipulada diretamente. Enquanto que as definidas pelos usurios, podem ser manipuladas. Existem tambm as linguagens que provem que os usurios definam tipos abstratos de dados, que devem satisfazer as seguintes condies. (a) A associao de uma representao s operaes concretas em uma unidade apropriada da linguagem, a qual, implementa os novos tipos; (prottipos e nomeclatura) (b) Esconder a representao do novo tipo das unidades que usam este tipo. (encapsulamento) Onde (a) faz com que as verso final do programa reflita as abstraes encontradas durante o projeto do programa. A estrutura resultante do programa fica auto-explicativa. A propriedade (b) facilita a modificabilidade do programa. O conceito tipo abstrato de dados vem do princpio de esconder informao. Tipos abstratos de dados escondem detalhes de representao e direcionam o acesso aos objetos abstratos por meio de procedimentos. A representao est protegida contra manipulao direta. A modificao da implementao de um tipo abstrato no afeta o resto do programa. a.ii) Abstrao de Controle Estruturas de controle descrevem a ordem em que instrues ou grupos de instrues devem ser executadas. Como nas abstraes de dados, abstraes de controle podem determinar reas de aplicao. As estruturas de controle podem ser classificadas em: (a) A nvel de instruo: Aquelas que so usadas para ordenar a ativao de instrues individuais. (b) A nvel de unidade: Aquelas que so empregadas para ordenar a ativao de unidades de programa. a.ii.i) A nvel de instruo as mquinas convencionais fornecem dois tipos de controle: seqencializao e desvio. (a) Seqencializao Incrementao automtica do contador de programa aps cada instruo. (b) Desvio: Altera o valor do contador de programa para uma posio desejada, ao invs da prxima instruo.
13
a.ii.ii) A Nvel de Unidade As linguagens de programao fornecem meios para agrupar instrues implementando abstraes de ao em uma unidade de programa apropriada, tais como, sub-programas e blocos ( sub-programas em grau menor). Uma chamada de uma sub-programa fora a transferncia do controle para o mesmo, que aps completar sua tarefa devolve o controle para a unidade chamadora. b) Correo de Programa Correo um dos requisitos bsicos de qualquer programa ou sistema. Existem dois mtodos para se construir programas corretos, so eles: (a) Correo de Erros Consiste basicamente em sanar um erro de um programa j escrito, quando o mesmo aparece, ou seja, descoberto; (b) Preveno de Erros: Isto , construir programas, ou tentar construir, j corretos (o que improvvel). Uma maneira de favorecer a produo de programas corretos tornar os esforos de projetos e codificao fceis de enfrentar, de modo que possa ter confiana no comportamento desejado do sistema. Abstraes de dados e controle so ferramentas poderosas para dominar a complexidade do programa. Mecanismos de linguagens que permitem a produo de programas bem estruturados e corretos. Estas estruturas de programas possibilitam subdividir a tarefa complexa de raciocinar sobre um objeto grande (o programa inteiro) em pensar sobre objetos abstratos menores. Alm disso, as unidades do programa, individualmente, devem ser fceis de escrever e de entender, de modo que possveis erros possam ser localizados e corrigidos com simplicidade. Mas, mesmo os programas que so feitos sob a mxima rigorosidade no esto livres de erros, logo so necessrias estratgias para remover tais erros, tal como testes de consistncia, que so providos pela prpria linguagem. Estes testes consistem em verificar se o programa esta sintaticamente e semanticamente correto. Testes de consistncia efetuados antes de executar o programa so chamados de testes estticos, e os efetuados em tempo de execuo so chamados de testes de tempo de execuo (ou dinmicos). O mtodo tradicional de certificar programas consiste em testar o programa submetendo uma amostra de entradas, tiradas dos documentos de especificao do programa, e observar se as sadas condizem com o esperado. Porm, esse mtodo identifica a presena de erros, mas no a ausncia! Devido a esse problema um outro mtodo a verificao de programas; que almeja a correo do programa independente de sua execuo.
14
c) Programao de Grande Porte A produo de grandes sistemas de programao freqentemente requer a coordenao das atividades de um grande nmero de pessoas. Os programas so montados como coleo de mdulos individuais, possivelmente escritos por pessoas distintas e codificados em diferentes linguagens. A gerncia bem sucedida do projeto, produo, correo e manuteno de tais sistemas de programao uma tarefa formidvel, envolvendo problemas que se estendem desde a sociologia das relaes humanas at as metodologias para a produo de programas. Esta gerncia requer metodologias e ferramentas adequadas a fim de manter a complexidade sob controle. Supe-se implicitamente que os sistemas grandes so constitudos de componentes individuais, chamados mdulos. A modularidade, em verdade, geralmente reconhecida como o nico guia disponvel para dominar a complexidade do projeto e da implementao de sistemas grandes e complexos. Uma noo mais til de modularidade fica em termos de independncia. Isto significa que cada mdulo deve ser compreendido, e possivelmente implementado, independentemente dos outros mdulos do sistema. Cada mdulo deve realizar uma nica funo conceitual simples do sistema; consequentemente, restries sobre o tamanho dos mdulos aparecem automaticamente como subprodutos do processo de projeto. Ocultar informaes como princpio de projeto favorece a produo de mdulos altamente independentes de fato, decises de projeto internas a um mdulo ficam ocultas e no afetam a correo da cooperao entre os mdulos, uma vez que as interfaces dos mdulos tenham sido projetadas, os mdulos podem ser desenvolvidos independentes uns dos outros, armazenados em uma biblioteca e depois montados para construir um programa nico. As linguagens de programao devem prover mecanismos para a definio de mdulos e para ocultar informao. Devem tambm fornecer mecanismos para estruturar uma coleo de mdulos em um sistema nico. Finalmente, deve ser possvel desenvolver e certificar mdulos separadamente. A combinao de uma linguagem de programao adequada com vrias ferramentas poderosas, integradas, fceis de usar e sensveis linguagem, isto , um ambiente para desenvolvimento de sistema, torna-se atualmente o fator chave em melhorar a qualidade dos programas. 2 2.1 Caracteristicas Gerais de uma Linguagens de Programao Especificao de uma LP
A descrio de uma linguagem de programao envolve dois aspectos: sintaxe e semntica. A sintaxe o conjunto de regras que determinam quais construes so corretas e a semntica a descrio de como as construes sintaticamente corretas so interpretadas ou executadas.
15
Ex: a := b (Pascal) comando de atribuio correto (sintaxe) substitua valor de a com o valor atual de b (semntica)
2.1.3 Sintaxe de uma LP A sintaxe de uma LP descrita por uma Gramtica que tem como elementos bsicos: 1. Conjunto de Smbolos Terminais (T): aparecem nas construes da LP; um conjunto de caracteres. 2. Conjunto de Smbolos No Terminais (NT): no presentes na LP; nomes de categorias sintticas definidas pelas produes. Notao: < . 3. Conjunto de Produes (P): definies de smbolos no terminais. Forma: <NT ::= {T U NT}*. 4. Smbolo Inicial (S): um dos NT. Exemplo: Gramtica de uma linguagem de calcular em BNF (Backus Naur Form): P: <clculo> ::= <expresso> = <expresso> ::= <valor> | <valor><operador><expresso> <valor> ::= <nmero> | <sinal><nmero> <nmero> ::= <semsinal> | <semsinal>.<semsinal> <semsinal> ::= <dgito> | <dgito><semsinal> <dgito>::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 <sinal> ::= + | <operador> ::= + | - | / | * --- T, --- NT, --- Metalinguagem S = <clculo> Na notao anterior, poderamos expressar: opcionalidade [ ], repetio { } e alternncia |. O uso desses 3 metasmbolos estende a BNF para a notao EBNF (Extended BNF). Rescrevendo os NT <expresso>, <valor>, <semsinal. e <nmero>: <expresso> ::= <valor> [<operador><expresso>] <valor> ::= [<sinal>] <semsinal> [.<semsinal>] <semsinal> ::= <dgito> {<dgito>} PS: <nmero> pode ser eliminado. Uma Gramtica pode ser usada para gerar sentenas vlidas e para
verificar se uma seqncia de smbolos vlida. Gerando sentena vlida:
Cadeia Atual S = <clculo> <expresso> = <valo><operador><expresso> = <nmero><operador><expresso> = <semsinal><operador><expresso> = <dgito><semsinal><operador><express o> = 2<semsinal><operador><expresso> = 2<dgito><operador><expresso> = 25<operador><expresso> = 25 * <expresso> = 25 * <valor> = 25 * <nmero> = 25 * <semsinal>.<semsinal> = 25 * <dgito>.<semsinal> = 25 * 1.<semsinal> = 25 * 1.<dgito> = 25 * 1.5 = Verificando se 6 + 3 / 12 = um clculo:
Produo Aplicada 1 3 4 6 9 12 8 15 24 2 4 7 8 11 8 15 cadeia final
17
<dgito> <semsinal> <nmero> <valor> | | | <expresso>
<operador> | | | | | |
<dgito> <semsinal> <nmero> <valor> | | <expresso>
<operador> | | | | |
<dgito> | <semsinal> <nmero> <valor> <expresso>
<dgito> <semsinal>
| | | | | | | |
Reduo de uma cadeia invlida (6 * =):
6 <dgito> <semsinal> <nmero> <valor> ?
* <operador> | | | ?
= | | | | ?
Gramticas que podem ser descritas em BNF e EBNF so conhecidas como Gramticas Livres de Contexto: definies de NT so independentes do contexto em que o NT aparece. A maioria das LPs no so Livres de Contexto - elas contm algumas regras sensveis ao contexto. Ex: "varivel deve ser declarada antes de ser usada". So, assim, chamadas linguagens sensveis ao contexto. Os mtodos formais para reconhecer linguagens sensveis ao contexto so bastante complexos. Na prtica, especifica-se uma LP como livre de contexto e trata-se a sensibilidade ao contexto de maneira informal.
18
2.1.4 Semntica de LP A semntica de uma LP, que corresponde a como esta LP ser implementada, pode ser descrita de maneira formal, porm, em geral, descrita de maneira informal. Esta apresentao dar um enfoque operacional ao problema, com o objetivo de fornecer uma viso dos problemas encontrados quando da implementao de linguagens.
2.2
Traduo de uma LP
Existem dois mtodos para se traduzir um programa escrito em uma determinada linguagem de programao para a linguagem de mquina: Interpretao e Compilao. 2.2.3 Interpretao Um interpretador traduz o programa fonte um comando por vez e chama uma rotina para executar esse comando. A vantagem que o interpretador no traduz comandos que podem no ser executados e pode relatar erros na linguagem original em cada ponto de execuo. Na prtica as linguagens interpretadas servem para a realizao de uma prototipagem rpida. 2.2.4 Compilao Um Compilador traduz o programa fonte inteiro, produzindo um outro programa equivalente, em linguagem executvel. A vantagem que o compilador precisa traduzir um comando apenas uma nica vez, no importando quantas vezes ele ser executado. Na prtica o compilador usado para gerar o cdigo definitivo (eficiente) de um programa. O processo de compilao:
19
Fases Principais da Compilao:
20
2.3
Caractersticas de Design de LP
O principal objetivo de uma LP auxiliar o programador no processo de desenvolvimento de software. Isso inclui auxlio no projeto, implementao, teste, verificao e manuteno do software. Algumas caractersticas que contribuem para isso so:
Simplicidade: Nvel semntico: nmero mnimo de conceitos e estruturas. Os conceitos devem ser naturais, de fcil aprendizado, com pouco risco de m interpretao. Nvel sinttico: cada conceito deve ter representao nica e "clara" - evitar sintaxe muito concisa, pois isto contraprodutivo para inteligibilidade. Deve-se excluir mltiplas representaes e representaes confusas.
Abstrao: apenas aspectos relevantes dos objetos. Tem reflexo nas tarefas de design, implementao e modificao de programas. Nvel de dados: programador pode trabalhar mais efetivamente usando abstraes mais simples, que no incluam detalhes irrelevantes dos dados. Nvel de procedimentos: facilita modularidade e boas prticas de design.
21
Expressividade: facilidade com que um objeto pode ser representado. As LPs devem permitir uma representao natural de objetos e procedimentos (por exemplo, estruturas de dados e de controle apropriadas). Simplicidade e Expressividade so caractersticas um tanto antagnicas e a maior aplicao de uma ou outra depende do domnio de aplicao do problema. Deste modo deve-se restringir os problemas a domnios especficos. Ortogonalidade: refere-se integrao entre os conceitos, o grau de interao entre diferentes conceitos, e como eles podem ser combinados de maneira consistente. Por exemplo, quando uma "string" no pode ser passada como parmetro, os conceitos de "string" e "parmetro" no podem interagir, e portanto, h falta de ortogonalidade. Alm disso, se uma LP usa o operador := para atribuio de "inteiro" e <para atribuio de "string", ento o conceito "atribuio interage inconsistentemente com os de "inteiro" e "string". A ortogonalidade reduz o nmero de excees de regras e torna a LP mais fcil de ser aprendida. Tambm leva a dificuldades: combinaes difceis de se implementar ou mesmo improvveis de ocorrer. Portabilidade: movimento de um programa de uma mquina a outra. Utilizao de um padro independente de mquina. Escolha de uma LP
2.4
A escolha de uma linguagem de programao deve basear-se em 7 critrios bsicos:
implementao disponibilidade quanto plataforma eficincia: velocidade de execuo do programa objeto experincia do programador competncia do grupo envolvido necessidade de rodar em diferentes mquinas certos tipos de aplicao acomodam-se melhor em certas sintaxes aplicao X facilidades por exemplo, para processamento concorrente pode-se usar ADA, para utilizao de recursividade pode-se usar Pascal
competncia na LP
portabilidade sintaxe semntica
ambiente de programao
22
ferramentas para desenvolvimento de software diminuem o esforo de programao bibliotecas aplicao X modelo de computao por exemplo, para realizao de busca heurstica adequado o modelo lgico, para simulaes, o modelo orientado a objeto
modelo de computao
3 Paradigmas de LP
3.1 Paradigma Imperativo de LP
O modelo Imperativo baseado na perspectiva do computador: a execuo seqencial de comandos e o uso de dados so conceitos baseados no modo como os computadores executam programas no nvel de linguagem de mquina. Este modelo o predominante. As LPs imperativas so de fcil traduo. Um programa imperativo equivalente a uma seqncia de modificaes de locaes de memria. Linguagens Imperativas: FORTRAN, COBOL, ALGOL 60, APL, BASIC, PL/I, SIMULA 67, ALGOL 68, PASCAL, C, MODULA 2, ADA. 3.1.1 Binding 3.1.1.1 "Information Binding" As LPs imperativas imitam as aes dos computadores ao nvel de linguagem de mquina (LM). Nesse nvel, os computadores operam com 2 unidades principais: CPU e memria. Uma unidade de execuo tpica em LM consiste de 4 passos: 1 - Obter o endereo de locaes para um resultado e 1 ou mais operandos 2 - Obter o dado operando da(s) locao(es) do operando 3 - Computar o dado resultado dos dados operandos 4 - Armazenar o dado resultado na locao do resultado Exemplo: A := B + C seria executado como: 1 - Obter os endereos de A, B e C 2 - Obter os dados dos endereos B e C 3 - Computar o resultado de B + C 4 - Armazenar o resultado na locao de A Apesar da abstrao de endereos em nomes, as LPs imperativas mantm os 4 passos como uma unidade de programa padro. Essa unidade de
execuo se tornou a unidade fundamental de LP imperativas - e chamada de comando de atribuio (em BNF: <nome> <op_atribuio> <expresso>). De fundamental importncia para a performance dessa atribuio o estabelecimento e uso de um nmero de bindings ("ligaes"): passo 1: binding entre nomes e locaes de operandos e resultados passo 2: binding entre locao e valor para estabelecer valores de operandos passo 4: binding entre locao do resultado e o valor computado No passo 3, a computao depende da interpretao dos dados e dos operadores definidos. LPs relacionam dados e operadores atravs de tipos. Veremos o papel de tipo em binding. Alm disso ser discutido o Escopo dos bindings: definio e mudana de bindings. Dados objetos & Bindings Dado objeto = (L, N, V, T) onde L - locao, N - nome, V - valor, T - tipo Binding a atribuio de valor a um dos quatro componentes acima. Esses bindings podem ser alterados em certas ocasies.
Os bindings podem ocorrer em tempo de compilao, em tempo de loading (quando o programa LM gerado pelo compilador est sendo alocado locaes especficas na memria), ou em tempo de execuo. Bindings de locao geralmente ocorrem em tempo de loading, mas tambm podem ocorrer em tempo de execuo (variveis em procedimentos e alocao dinmica). Bindings de nome ocorrem tipicamente em tempo de compilao, quando uma declarao encontrada. (em arrays e records ocorrem bindings
compostos de nomes). Bindings de tipo ocorrem geralmente em tempo de compilao, atravs de declaraes de tipo. Veja exemplos dos efeitos da declarao de tipos em ADA nas figuras seguintes. Binding de tipo dinmico ocorre durante tempo de execuo, no havendo declaraes. O tipo do dado objeto determinado pelo tipo do valor, e portanto, uma mudana de valor implica em novo binding. 3.1.1.2 Escopo de Binding e Unidades de Execuo Divises de um programa: programa - maior diviso; unidade executvel fundamental blocos comando - menor diviso; unidade indivisvel
O objetivo de se juntar unidades de execuo, neste caso, para identificar o escopo de bindings. Comandos: unidade de controle fundamental de LPs imperativas menor unidade traduzvel comandos compostos (condicionais, iterativos)
Em LPs como LISP e PROLOG, os comandos possuem um nico formato: LISP - (nome_funo (par1 ... parn) <corpo>) PROLOG - predicado (arg1, ..., argn) :- <corpo>. A maioria das LPs imperativas possuem vrias sintaxes para tipos diferentes de comandos. Referncia a comandos: labels <label> : <comando> Binding - tempo de compilao (Pascal, ADA, FORTRAN) - tempo de execuo (SNOBOL, APL) Variaes: labels podem ser: obrigatrios - BASIC opcionais - Pascal, ADA, FORTRAN, C inteiros - Pascal, FORTRAN, BASIC identificadores - ADA, C
25
declarados explicitamente - Pascal declarados implicitamente - ADA, FORTRAN detectados por posio - FORTRAN detectados por notao - Pascal, C um comando por linha - FORTRAN marca delimitadora - ADA, C, Pascal (em ADA e C ';' termina comandos e em Pascal separa comandos) ... x := x + 1 else ...
Delimitao de Comandos:
Pascal:
ADA, C: ... x := x + 1; else ... Blocos: conjunto de comandos para atender a determinado fim. 1 - Escopo de estrutura de controle Estruturas condicionais Estruturas iterativas 2 - Escopo de procedimentos ou funes 3 - Unidades de compilao Blocos execuo compilados separadamente e depois unidos para
4 - Escopo de bindings Bloco de comandos sobre os quais bindings especficos so vlidos 3.1.1.3 Escopo de Binding de Nome Blocos que definem um escopo de binding de nome contm, em geral, duas partes: 1. Uma seo de DECLARAES, que define os bindings que valem dentro do bloco 2. Uma seo EXECUTVEL, que contm os comandos do bloco, onde
26
valem os bindings Sintaticamente, isso requer delimitadores. Ex: ... BLOCK A; DECLARE I; BEGIN A ... {I de A} - binding vlido END A; ... Num bloco, dois tipos de bindings: local - feito por declaraes no bloco no-local - feito por declarao fora do bloco. Blocos aninhados: program P; declare X; begin P ... {X de P} block A; declare Y; begin A ... {X de P; Y de A} block B; declare Z; begin B ... {X de P; Y de A; Z de B} end B; ... {X de P; Y de A} end A; ... {X de P} block C; declare Z; begin C ... {X de P; Z de C} end C; ... {X de P} end. Poltica do Escopo Lxico ou Esttico: 1. Se um nome tem uma declarao num bloco, este nome ligado ao objeto especificado na declarao. 2. Se um nome no tem declarao num bloco, ele ligado ao mesmo
27
objeto ao qual ele foi ligado no bloco que contm o bloco atual, no texto do programa. Se o bloco no est contido em outro, ou se o nome no foi ligado no bloco que contm este, ento o nome no est ligado a qualquer objeto no bloco atual. "Hole-in-scope" - Situao em que um bloco redeclara um nome j ligado no ambiente que o contm. Neste caso, a declarao local se sobrepe ao binding no-local, fazendo o objeto ligado no-localmente inacessvel no bloco atual. Ex: program P; declare X, Y; begin P ... {X de P; Y de P} block A; declare X, Z; begin A ... {X de A; Z de A; Y de P; X de P inacessvel em A} end A ... {X de P; Y de P} end P; Escopo Esttico x Escopo Dinmico Escopo Dinmico: O ambiente "global" de uma unidade (procedure) o ambiente da unidade que a chamou. Isto , uma procedure herda como ambiente global aquele da unidade que a chamou e, portanto, este s pode ser determinado em tempo de execuo. Contornando o "Hole-in-scope": ADA - via sintaxe: no exemplo, P.X refere-se ao objeto X ligado em P, enquanto X o objeto ligado em A. 3.1.1.4 Escopo de Binding de Locao Hiptese assumida: binding de locao feito em tempo de loading, permanecendo vlido durante toda a execuo do programa. Efeito colateral: ao re-executar um bloco, as variveis locais reteriam os valores da execuo anterior. Se um novo binding de locao for feito a cada nova entrada no bloco, nenhuma suposio poderia ser feita. Exemplo: program P declare I;
begin P for I := 1 to 10 do block A; declare J; begin A if I = 1 then {I de P; J de A} J := 1 else J := J * I {assume-se que J retm valor de execuo prvia} endif end A; end P Desvantagem: memria para todos os blocos do programa deve ter reservada por todo o tempo de execuo do programa. Alternativa: (binding dinmico) Fazer o binding de locao, bem como o de nome, em tempo de execuo, a cada entrada de um bloco, desfazendo esses bindings quando da sada do bloco. (Alocao dinmica de memria). Extenso do binding: perodo de tempo, durante execuo, em que o binding vlido. Implementao: via registros de ativao que so registros contendo informaes sobre uma unidade de execuo, necessrias para restabelecer sua execuo, depois de ela ter sido suspensa. Para efeito de binding de locao, o registro de ativao precisar conter apenas as locaes para todos os objetos ligados localmente, mais um ponteiro para o registro de ativao do bloco que o contm. Funcionamento: Conforme um bloco ativado, seu registro colocado no topo de uma pilha. No trmino de sua execuo, seu registro desempilhado. Uso da pilha para localizar objetos: 1. Procura no registro do topo pelo objeto ligado ao nome. 2. Se no encontrar, procure-o no registro apontado por ele; continue nesse processo at encontr-lo na lista, ou a lista acabar. Esta busca pode ser otimizada, uma vez que se sabe, em tempo de compilao, a estrutura da pilha e de cada registro de ativao. Em C: "source file" - outra unidade de execuo Uma declarao precedida pela palavra extern torna visvel um objeto daquele nome, que tenha sido definido num source file diferente. Esses
arquivos podem ser compilados separadamente e, portanto, servem como unidades de compilao. extern int compare_strings(); extern char *read_string(); extern void copy_string(); 3.1.1.5 Exerccios 1. Em quais situaes bindings de locaes so feitos em tempo de execuo? 2. Que fatores deve-se considerar ao escolher entre um espao de identificadores mais ou menos restritivo? 3. Algumas LPs permitem o binding de tipo a um objeto em tempo de execuo. Discuta vantagens e desvantagens desta estratgia. 4. Quando uma LP oferece tipos reais em ponto fixo e em ponto flutuante, o que importante considerar ao decidir o tipo de um dado objeto? 5. Que tipo de uso se faria de bindings de labels em tempo de execuo? Que perigos isso oferece? 6. Considere o mecanismo de passagem de parmetros do Pascal. a) O binding feito entre os parmetros atuais e os formais esttico ou dinmico? b) Especule como esse mecanismo funcionaria se fosse o oposto do que voc respondeu acima.
3.2
Paradigma Declarativo
Uma linguagem declarativa aquela na qual um programa especifica uma relao ou funo. Quando programa-se no estilo declarativo, no faz-se atribuies de variveis do programa. Essas linguagens so de mais alto nvel do que as linguagens imperativas. Os paradigmas declarativos so tirados da matemtica: lgica, da teoria de funes e do clculo relacional. 3.2.3 Programao Lgica A programao lgica baseada em um subconjunto do clculo de predicados, incluindo declaraes escritas como clausulas de Horn. O calculo de predicados prov axiomas e regras, tal que um fato pode
produzir novos fatos a partir de outros fatos conhecidos. Clausulas de Horn permitem somente um novo fato ser deduzido em uma nica declarao. Um programa baseado em lgica consiste de uma srie de axiomas ou fatos, regras de inferncia e uma pergunta ou teorema a ser provado. A resposta verdadeira se os fatos satisfazem ao teorema e falso do contrrio. PROLOG, PARLOG e PROPLOG so exemplos de linguagens deste paradigma. 3.2.4 O Paradigma Funcional de LP
O modelo Funcional focaliza o processo de resoluo do problema. A viso funcional resulta num programa que descreve as operaes que devem ser efetuadas para resolver o problema. Linguagens Funcionais: LISP 3.2.4.1 Paradigma Funcional Funo: f: {domnio} {contra-domnio} Programa: p: {possveis entradas} {possveis sadas} Uma funo tem trs componentes bsicos: domnio: conjunto de objetos aos quais a funo se aplica, contra-domnio: conjunto de objetos resultantes da aplicao da funo, e definio: especificao de como um objeto do contra-domnio determinado a partir do domnio. H um quarto componente opcional: o nome da funo. Exemplo 1: funo double Domnio: Z Contra-Domno: Z Definio: x + x, onde x elemento do domnio Nome: double Notao matemtica: double(x) = x + x double: integer integer Note que o operador + usado na definio, e + uma funo tambm. Uma notao mais consistente seria ento: +(x, y), indicando uma funo (+) com domnio o conjunto de pares de inteiros.
31
Expresso Lambda (Church - 1941) Definio de funo: [<nome_funo>] l <lista nomes elementos>.<definio> Ex: double l x.x + x Aplicao da funo: <especificador_funo>:<valor_domnio> , especificador_funo pode ser o nome ou a definio da funo. Ex: Aplicar a funo double ao valor 2: double: 2 ou lx.x + x: 2 Exemplo 2: funo max max: integer x integer integer max lx, y.if x y then x else y max:<4, 2 Exemplo 3: funo abs abs lx.max:<x, -x> abs: 6 max: <6, -6> if 6 > -6 then 6 else -6 6 Composio de funes: Notao matemtica: f(x) = abs(double(x)) Expresso Lambda: definimos essa composio por um novo operador: f abs o double isto f equivalente a sucessivas aplicaes de double e abs: f: -3 double: -3 abs: -3 +-3 abs: -6 if -6 > 6 then -6 else 6 6 1.3. O Paradigma Orientado a Objeto (OO) de LP O modelo Orientado a Objeto focaliza mais o problema. Um programa OO equivalente a objetos que mandam mensagens entre si. Os objetos do programa equivalem aos objetos da vida real (problema). A abordagem OO importante para resolver muitos tipos de problemas atravs de simulao. A primeira linguagem OO foi Simula, desenvolvida em 1966 e depois refinada em Smalltalk. Existem algumas linguagens hbridas: Modelo Imperativo mais caractersticas de Orientao a Objetos (OO). Ex: C++. abs: onde
32
No modelo OO a entidade fundamental o objeto. Objetos trocam mensagens entre si e os problemas so resolvidos por objetos enviando mensagens uns para os outros. Linguagens Orientadas a Objeto: SMALL TALK
33
4 4.1
Organizao de Dados Tipos de dados
De modo geral programas so feitos para produzir dados (resultados), a partir de outros dados de entrada. Desta forma, as linguagens provem conjuntos de dados pr-determinados e tambm formas para usurios definirem seus prprios tipos de dados. Alguns desses tipos de dados sero descritos em seguida. 4.2 Tipos Embutidos de Dados Este tipo provido pela prpria linguagem, como tipos primitivos. Exemplos: Inteiros, Reais, Lgicos,... Estes seguem quatro propriedades teis: 1 2 3 44.3 Invisibilidade da representao; Uso correto de variveis pode ser testado em tempo de traduo; Desambiguao de operadores pode ser feita em tempo de traduo; Controle de preciso.
Tipos Agregados de Dados
As linguagens de programao permitem que o programador especifique agregaes de objetos elementares e por sua vez agregados de agregados. Exemplo: Vetores de inteiros, Strings,... 4.3.1 Produto Cartesiano O produto cartesiano de N conjuntos A1, A2, ..., An denotado por A1xA2x...xAn, um conjunto cujos elementos so n-tplas ordenadas (a1, a2, ..., an) onde ai Ai. Exemplos: records (COBOL, Pascal); structures (C, Algol68). 4.3.2 Mapeamento Finito Um mapeamento finito uma funo de um conjunto finito de valores de um tipo do domnio DT em valores de um tipo do co-domnio CT. As linguagens de programao possuem um mecanismo de array que permite a definio de mapeamento finito.
Exemplo:
var a: array[1..5] of real; (pascal) float a[5];
Onde existem trs tipos de escolhas possveis: 1- Amarrao em tempo de compilao; 2- Amarrao em tempo de criao do objeto; 3- Amarrao em tempo de manipulao do objeto. 4.3.3 Seqncias Uma seqncia consiste em um nmero arbitrrio de ocorrncias de itens de dados e de um determinado tipo de componente CT. Este mecanismo de estruturao tem a propriedade, importante, de deixar em aberto o nmero de ocorrncias do componente e, portanto, requer que a implementao seja capaz de armazenar objetos de tamanho arbitrrio. Exemplo: Strings, Arquivos,.... 4.3.4 Recurso Um tipo de dados recursivo T pode Ter componentes que pertenam ao prprio tipo T. Para definir-se um tipo recursivo de dados pode-se usar o nome do prprio tipo na sua definio. Exemplo: Listas de ponteiros, rvores, ... 4.3.5 Unio Discriminada A unio discriminada um mecanismo de estruturao que especifica que uma escolha ser feira dentre diferentes estruturas alternativas. Cada estrutura alternativa chamada de uma variante. Exemplo: Var a: record case tag of 1: b: string; 2: b:integer; end; union 4.4 Tipos Definidos Pelo Usurio (Pascal);
(C).
35
As linguagens permitem que o programador defina objetos de informao complexos como agregados de itens elementares. Essas linguagens permitem tambm que os programadores renomee tipos existentes ou nomee novos tipos agregados definidos. Exemplos: typedef byte type byte char; nome[10]; (C);
complexo = record partreal:real; (Pascal). parteim:real; end; Isso favorece a legibilidade, modificabilidade, fatorao e testes de consistncia. 4.5 Converso de Tipos
Freqentemente necessrio converter um valor de um tipo em um valor de outro tipo, por exemplo quando queremos somar uma varivel com uma varivel real. Na maioria das linguagens essa converso implcita (baseada em uma hierarquia de tipos da linguagem), que pode levar a erros. Uma outra maneira, fazer uma converso por referncia, forando a converso. Exemplos: float int r,q; i; /* h uma converso implcita de i para float, chamada de alargamento */ /* h uma converso forada de i para float usando um molde (chamada de referenciao ou casting) */
q = i/r; r = (float)i;
4.6
reas Problemticas
4.6.1 Tipagem Forte Um importante efeito da introduo de tipos a possibilidade de testes estticos de tipos. Os programas resultantes tem maior chance de estarem corretos, e tambm de serem mais eficientes, porque no necessrio ter descritores em tempo de execuo nem efetuar testes sobre eles. Uma linguagem dita fortemente tipada se permite que todos os testes de tipos sejam efetuados estaticamente.
4.6.2 Compatibilidade de Tipos Regras de compatibilidade (ou equivalncia) de tipos devem dar uma especificao exata de como o mecanismo de testes de tipos deve ser aplicado. Existem duas definies de noes de compatibilidade de tipos: 1- Equivalncia de nomes: Duas variveis possuem tipos compatveis se tm o mesmo nome de tipo, definido pelo usurio ou primitivo, ou de aparecem na mesma declarao. 2- Equivalncia estrutural: Duas variveis tm tipos compatveis se possuem a mesma estrutura. 4.6.3 Ponteiros Ponteiros comearam a ser criticados em meados da dcada de 1970. Assim como os gotos irrestritos alargam o contexto a partir do qual uma instruo rotulada pode ser executada, ponteiros irrestritos alargam o contexto a partir do qual pode-se Ter acesso a um dado. Ponteiros compreendem a ferramenta bsica fornecida para se representar dados definidos recursivamente. Como um mecanismo de linguagem de baixo nvel, contudo, podem ser usados para outros propsitos alm dos originalmente pretendidos. Podem tornar os programas menos compreensveis e, freqentemente, inseguros por vrias razes, entre elas: violaes de tipos, acesso a reas de dados no alocadas.
Estruturas de Controle
5.1
Nvel de Comando
Existem trs tipos de estruturas de controle a nvel de comando: Seqencial, Seleo e Repetio. Estruturas de controle neste nvel contribuem sensivelmente para a legibilidade e a menutenibilidade de programas. 5.1.1 Controle Seqencial Mecanismo de estruturao mais simples existente em linguagens. usado para indicar que a execuo de um comando (B) deve seguir a execuo de um outro comando (A). De modo geral, pode ser escrito como A; B, onde ; denota o operador de controle seqencial. As linguagens provem
37
formas de agrupar comandos de uma seqncia, dito comando composto (exemplo: Pascal begin e end e em C { e }). 5.1.2 Controle de Seleo Estruturas de controle permitem ao programador especificar que uma escolha deve ser feita entre um certo nmero de comandos alternativos. Exemplo: Os comandos: if then else; case; if then elifthen ... elifthen else endif; switch case.
5.1.3 Controle de Repetio A maioria dos programas teis envolvem a repetio de um nmero de aes. Em conseqncia disso, todas as linguagens de alto nvel possuem estruturas de controle que permitem a especificao da execuo repetida de um conjunto de instrues. Exemplos: do{ bloco } while(boolean); while(boolean){ bloco }; for (cont; boolean;...) { bloco}
Condies de parada lgica Condies de parada via iterador
5.1.4 Estruturas de Controle Definidas pelo Programador Existem linguagens que proporcionam um grau de abstrao ainda maior, permitindo ao programador o uso de variveis de controle de qualquer tipo abstrato e fornecendo mecanismos para a especificao da seqncia de valores para uma varivel de controle. Estas linguagens podem ser chamadas de extensveis, porque o programador pode aumentar a linguagem de base pela definio de novos tipos (abstratos) de dados, novas operaes (com procedimentos) e tambm novas estruturas de controle. Exemplo: na linguagem CLU for atomo : no in lista(x) do executa ao no atomo
38
5.2
Estrutura de Controle a Nvel de Unidade
Estas estruturas so mecanismos para a especificao do fluxo de controle entre unidades de programa. O mecanismo mais simples cria novo ambiente de referncia e executado quando encontrado no processamento seqencial. Mecanismos mais poderosos permitem ao programador a transferncia de controle entre unidades por meio de chamadas explcitas. Existem duas formas de transferir o controle entre unidades (sub-programas). Uma forma dita explicita, e acontece quando uma unidade especifica pelo nome a chamada de uma outra unidade, desta forma a unidade chamada dita implcita. Comumente isso acontece quando a transferncia do controle feita sem especificar a unidade chamada (exemplo: tratadores de excees). 5.2.3 Unidades Subordinadas Chamadas Explicitamente Esta classe cobre os sub-progamas, desde as sub-rotinas e funes e procedimentos. A passagem de parmetros permite a comunicao de dados entre unidades de programa. Ao contrrio do que ocorre com variveis globais, parmetros permitem que dados diferentes sejam passados a cada chamada da unidade, e oferece vantagens nos pontos de vista de legibilidade e modificabilidade de programas. A maioria das linguagens de programao usam critrios posicionais e mtodos alternativos para a amarrao de argumentos e parmetros em chamadas de unidades. As entidades que podem ser passadas como parmetros podem ser divididas em trs classes: dados, sub-programas e tipos. 5.2.3.1 Dados Como Parmetros Existem convenes diferentes para a passagem de parmetros para sub-programas. Entre estas convenes esto: - Passagem de referncia (ou compartilhamento) A unidade chamadora passa para a unidade chamada somente o endereo do parmetro. Passagem de cpia Neste mecanismo parmetros no compartilham memria com argumentos, em vez disso, eles se comportam como variveis locais. Passagem de nome
39
Como na passagem de referncia, um parmetro denota uma posio no ambiente da unidade chamadora, no sendo uma varivel local. 5.2.3.2 Sub-programas como Parmetros A passagem de sub-programas como parmetros til em muitas situaes prticas. Por exemplo, um sub-programa S que avalia propriedades de funes de uma varivel em um intervalo dado [a..b] pode ser escrito sem o conhecimento da funo, e pode ser usado para diferentes funes se os valores da funo so produzidos por um sub-programa que enviado a S como um parmetro. Como um outro exemplo, se a linguagem no proporciona mecanismos explcitos para o tratamento de excees, um sub-programa tratador de excees pode ser transmitido como parmetro unidade que pode acusar a exceo. A transferncia de um sub-programa como parmetro requer pelo menos a passagem de uma referncia ao seguimento de cdigo do argumento. Entretanto, o sub-programa sendo passado tambm pode acessar variveis no locais e, assim, tambm necessrio passar informao sobre o ambiente no local do argumento.
6
6.1
Introduo ao Paradigma Funcional

Histria da Programao Funcional
A histria da programao funcional inicia-se antes da invenso dos computadores. No princpio do Sculo XXI muitos matemticos estavam preocupados com as teorias dos infinitos (conjuntos) entre estes matemticos estava Giusepe Peano (1858-1932), que mostrou que os nmeros naturais podem ser obtidos: era finitas operaes de aplicao da funo sucessor, esta teoria tambm foi mostrada por Thoralf Skulem (1887-1963) via operaes recursivas semelhante o teorema de Peano. Assim, podemos identificar que nas primeiras dcadas do Sculo XX j surgiram as primeiras definies de funes de nmeros naturais e recurso. Por volta de 1930 com a evoluo da matemtica, houve vrias tentativas de formalizar a notao de constructibilidade (tambm conhecido como effective calcul abelity e computability). Entre estas formalizaes o mais famoso foi a definio de Turing tambm conhecido como Mquinas de Turing. Outra aproximao baseada nos trabalhos de Stalem e Peano, foi Funes Recursivas Gerais proposto por Godel em 1934. Uma terceira aproximao teve rumo direto programao funcional, que foi o clculo Lambda desenvolvido por Church Kleene no incio dos anos 30. Muitas outras aproximaes, tais como, algortmos de Morkov e Post Productions
40
Splem foram desenvolvidos ao mesmo tempo, todas com formulaes independentes e de compatibilidades equivalentes. Na dcada imediatamente precedente inveno dos computadores digitais, investigaes com funes recursivas lgicas e matemticas, mostraram que qualquer funo computvel pode ser expressado nas funes recursivas. Outro passo importante na histria da programao funcional foi o trabalho de John McCarthy, que em 1958 estudou o uso de listas ligados com funes recursivas e passagens de funes com parmetros de outras funes, juntando estas idias para posteriormente implementar uma linguagem que ficou conhecida como LISPI, foi descrita em um artigo , escrita por ele mesmo em 1960, Recursive Functinons of Symbolic Expressionsand their Computation by Machine. Isso pode ser visto como o incio da Programao Funcional. No fim dos anos 60 e incio dos anos 70 trouxe um aumento da ateno dos pesquisadores para a at ento chamada programao aplicativa. Em 1978 quando John Backus publicou um paper criticando severamente as linguagens de programao convencional. Backus que foi o principal inventor do FORTRAN, e propondo o desenvolvimento de um novo paradigma de programao. Paradigma, este, chamado de Programao Funcional.
6.2
Linguagens de Programao Funcional (P.F.)
As linguagens de P.F. diferem largamente em seus estilos sintticos, como poder ser visto nos vrios exemplos de programas em linguagens distintas. A razo, pelo qual existe essa diversidade nas sintaxes devido ao motivo das linguagens funcionais serem linguagens experimentais, ou seja, so experimentos com notaes. Uma das sntaxes existentes a Syntatic Sugar, ou melhor, uma linguagem mais conveniente para programa-se um Clculo Lambda, essa linguagem foi chamada de UNSUGARED LAMBDA CALCULUS (U.L.C.). Exemplo: Programao Funcional em U.L.C. ( xc.Cxg ) ( quo 192 24 ( ( fac (nk ( quo ( fac n ) ( prod ( fac k ) ( fac ( dif nk ) ) ) ) ) ) V ( fac n ( if ( equal n ) 1 ( prod n ( fac ( dif n1 ) ) ) ) ) ) ( ( xE. Exp ) (ab ( if ( equal b 1 ) a ( prod a ( E a ( dif b1 ) ) ) ) ) )
Alm desta linguagem, existem uma infinidade de outras linguagens funcionais conhecidas, tais como: ( phi ), IYSWIN ( if you see what I mean) proposta por Landim em 1966. Baseada na notao de Landim surgiram: Miranda (Turner Mirando 1985 b), Scheme, que muito similar ao LISP e finalmente a linguagem F.P. (Dackus 1978). Exemplo de cada uma destas linguagens, para o seguinte caso: C n, k = Em k! . ( n k )! K!
let C ( n , k ) fac n / [fackx fac ( n k )] let fac 0 1 fac n n x fac ( n 1 ) , if n > 0 192 / 24 let x C(x,6) 28
let E ( P , Q ) P x E ( P , Q 1 ) , if P > 0 E(P,0) 1 Em Scheme ( combinao ) ( define ( C n k ) ( / ( fat n ) ( * ( fat ( - n k ) ) ( fat ) ) ) ) ( define ( fat n ) ( if ( = n 0 ) 1 ( * n ( fat ( - n 1 ) ) ) ) ) ( define x ( / 192 24 ) ) (Cx6) 28 Em FP Def C / [ ! 1 , * [ ! 2 , ! - ] ] Def ! eq 0 1 ; * [ id , ! sub 1 ] Def eq 0 eq [ id , 0 ] Def sub 1 - 0 [ id , 1 ] Def x / : < 192 , 24 > C:<x,6>
42
6.3
Definio de Funo
Para programar com funo, devemos primeiro considerar os caminhos, pelos quais, as funes podem ser definidas. Matematicamente uma funo exatamente um conjunto de pares de entrada e sadas. Portanto, um caminho para definir a funo enumerar esses pares. Por exemplo, a definio da funo not Not true false Not false true De forma similia a definioda funo or Or (true, true) true Or (true, false) true Or (false, true) true Or (false, false) false Desta forma pode-se observar que este caminho no aplicvel a funes complexas, mtodo chamado de enumerative definition. Um outro caminho chamado de definition by composition, que consiste em definir uma funo atravs da composio de outras j prontas. Exemplo: Implica (x,y) ou (not x,y) Que define a funo implica, pela composio das funes or e not. Assim reduzindo a complexidade da definio da funo. Outra forma de x definir funes na recursividade. Por exemplo, se fossemos definir uma funo multiplicao , x, em termos de composies da funo soma, +, obteramos infinitas condies de tipo:
m*n
; se m= n; se m=1 n+n; se m=2 n+n+n; se m=3
Portanto torna-se impossvel fechar o problema, devido ao fato de no se conseguir prover todas as condies possveis desta forma. Ento para contornar esse problema, podemos definir essa funo atravs da composio da funo soma e aplicao dela nela mesma. Caindo, assim, em um processo recursivo, da seguinte forma; ; se m= m*n n+(m-1)*n; se m>
43
importante tambm, distinguir entre funes explcitas e definies implcitas: EXPLCITAS: So aquelas definies, que as variveis que aparecem do lado esquerdo das equaes, no aparecem do lado direito. Ex.: y = 2ax IMPLCITAS: So aquelas definies em que as variveis aparecem em ambos os lados da equao. Ex.: f (x) = f( g ( x ) ); Resumindo, funes recursivas so, em suma, de definies implcitas; ou seja, no podem ser resolvidas diretamente enquanto as explcitas podem.
6.4
Conceito de Programao Funcional
Programao em uma linguagem funcional consiste em construir definies e usar o computador para avaliar expresses. A funo primria de um programador construir uma funo (algoritmos) para solucionar um dado problema. Esta funo pode envolver um nmero de funes subsidirias, e deve ser escrita em notao que obedece os princpios matemticos normais. A funo primria do computador agir como um avaliador ou calculador: seu servio avaliar expresses e imprimir resultados. Neste respeito, o computador afe semelhante a uma simples calculadora de bolso. O que distingue o clculo funcional de uma simples calculadora a habilidade do progtramador de construir definies para aumentar a sua fora de clculo. Expresses que contm ocorrncias de nome de funes definidas pelo programador so avaliadas pelo uso de dadas definies como regras de simplificao (ou reduo) para converter estas expresses para a sua forma mais simples (produzir resultados). 6.5 Reduo de Expresso
O computador avalia uma expresso pela reduo para a sua forma equivalente simplificada e imprimindo o resultado. Os termos avaliao, simplificao e reduo so usados para descrever este processo. Para exemplificar como esse processo de reduo ocorre dentro do computador, tomemos a expresso: Square ( 3 + 4 ) Vamos avali-la pelo processo de reduo. Uma possvel seqncia de reduo seria a seguinte: Square ( 3 + 4 ) Square 7 ( + ) 7 * 7 ( square )
49 ( * ) outro caminho: Square ( 3 + 4 ) ( 3 + 4 ) * ( 3 + 4 ) (square) 7 *(3+4)(+) 7 * 7 (+) 49 (*)
7 Introduo Linguagem Scheme

7.1 Sobre a linguagem
Scheme um dialeto da linguagem LISP. Tendo herdado do LISP tipos de dados latentes (ou dinamicamente checados), interface interativa com o usurio, gerenciamento de armazenamento automtico e uso de ordem aplicativa de avaliao de argumentos. Scheme oferece recursividade de calda. Portanto, executar um procedimento com recursividade de calda dispensa controle de espao de pilha. Assim permitindo contrair-se procedimentos recursivos com comportamentos interativos, sem perder a eficincia. Devido a simplicidade e elegncia, o Scheme, tem sido largamente usado para fins educacionais. Prometendo, para o futuro significante impacto na cincia da computao em termos de pesquisa, principalmente no que diz respeito programao paralela e inteligncia artificial (sistemas especialistas). ( define ( fac x ) ( fac aux x 1 ) ) ( define ( fac aux x res ) ( if ( = x 0 ) res ) ( fac aux ( - x 1 ) ( * x res ) ) ) )
x * ( fac ( - x 1 ) )
7.2
Sintaxe da Linguagem
Neste ponto sero feitas comparaes entre as sintaxes de LISP e SCHEME, sob diversas situaes: A. DECLARAES Scheme ( define x E ) ( define ( f x ) E )
Lisp ( defconst x E ) ( defun f ( x ) E )

45
( define ( f x1 ... xN ) E ) ( let ( ( x 1 E1 ) ( ( x 2 E2 ) ( ( xN EN ) ) E )
( defun f ( x1 ... xN ) E ) ( let ( ( x1 E1 ) ( x 2 E2 ) ( x N EN ) ) E ) Labels ( ( f1 ( p1 ) E1 ) ( fN ( pN ) EN ) ) E)
( letrec ( ( f1 ( lambda ( p1 ) E1 ) ) ( fN ( lambda ( pN ) EN ) ) ) E) APLICAES E ABSTRAES Scheme (fE) ( f E1 E2 E3 ... EN ) ( apply F E ) ( lambda ( x ) E ) ( lambda ( x1 x2 ... xN ) E ) BOOLEANAS Scheme # t # f ou ( ) ( not E ) ( and E1 E2 ) ( or E1 E2 ) ( eq E1 E2 ) ( not ( eq E1 E2 ) ) ( if B T F) ( cond ( B1 T1 ) ( B2 T2 ) ( else F ) ) 7.3 Nmeros
Lisp (fE) ( f E1 E2 E3 ... EN ) ( apply F E ) # ( lambda ( x ) E ) # ( lambda ( x1 x2 ... xN ) E )
Lisp t , Nil ( not E ) ( and E1 E2 ) ( or E1 E2 ) ( eq E1 E2 ) ( not ( eq E1 E2 ) ) ( if B T F) ( cond ( B1 T1 ) ( B2 T2 ) (T F))
Scheme ( + E1 E2 ... EN ) ( * E1 E2 ... EN ) ( truncate ( / E1 E2 ) ) ( expt E1 E2 ) < , <= , = , >= , > ( not ( = E1 , E2 ) )
Lisp ( + E1 E2 ... EN ) ( * E1 E2 ... EN ) ( truncate ( E1 E2 ) ) ( expt E1 E2 ) < , <= , = , >= , > ( / = E 1 E2 )
46
7.4
String Lisp C C C C ... C C ( string = E1 E2 ) ( coerce E string ) (coerce E list) ?
Scheme C C C C ... C C ( string = ? E1 E2 ) ( list string L ) ( string list E ) ( length E ) 7.5 Seqncias
Scheme ( e1 , e2 , e3 ... eN ) ( list E1 E2 ... EN ) ( ) ( car L ) cabea ( cdr L ) resto ( cons e L ) insere na cabea ( length L ) ( member e L ) ( reverse L ) ( cadr L ) ( append L1 , L2 , ... LN ) 7.6 Funes Finitas
Lisp ( e1 , e2 , e3 ... eN ) ( list E1 E2 ... EN ) nil , ( ) ( first L ) , ( car L ) ( rest L ) , ( cdr L ) ( cons e L ) ( length L ) ( member e L ) ( reverse L ) ( cadr L ) ( append L1 , L2 , L3 ... LN )
Scheme ( ( x1 y1 ) ... ( xN yN ) ) ( list ( list E1 F1 ) ... ( list EN FN ) ( ) ( cadr ( assoc x L ) ) ( map car L )
Lisp ( ( x1 y1 ) ... ( xN yN ) ) ( list ( cons E1 F1 ) ... ( cons EN FN ) nil ( ) ( cdr ( assoc x L: test # equal ) ) ( map car # car L )
7.7
Formas Funcionais Scheme Lisp ( map car F E ) , ( map list F E ) # ( lambda ( x ) K )
( map F E ) ( lambda ( x ) K )
47
8 Desenvolvimento de Funes Bsicas em Scheme

8.1 Constantes e funes simples: Uma constante definida da seguinte forma: (define < contstant_name> < constant_value>) E para avaliar esta constante basta digitar o nome da constante definida na linha de comando do interpretador. Uma funo qualquer definida da mesma forma que uma constante, porm com uma ressolva do programa de parmetros. Seguindo, basicamente modelo abaixo: (define < function_name parameters> < function_developments>) Para avaliar uma funo deve-se digitar o nome da mesma com os devidos parmetros, entre parnteses, na linha de comando do interpretador. Exemplos de funes e constantes: Constantes: PI ( define PI 3.14159216 ) Verdadeiro ( define verdadeiro Falso ( define falso # f ) Funes: ( define ( pertence x 1 ) ( if ( null ? 1 ) #f ( if ( = x car ( ) ) #t ( pertence x ( cdr L ) ) ) ) ) ( define ( maior L ) ( if ( null ? ( cdr ( ) ) ( car ( ) ( if ( > ( car L ) ( maior ( cdr L ) ) ) ( car L ) ( maior ( cdr L ) ) ) ) )
#t)
Ex: ( 10 15 20 )
20 ( m ( 20 ) ) ( m ( 15 20 ) ) ( m ( 10 15 20 ) ) 8.2 If ( > 15 ? ) 20 If ( > 10 ? )
Depois o 20 sai, gera pendncia (?), e faz tudo de novo com o 15, depois com o 10
Algoritmos Recursivos
Algoritmo da seqncia de Fibonacci 1,1,2,3,5,8
Que ativam processos recursivos ( define ( fib n ) ( if ( < n 3 ) 1 ( + ( fib ( - n 1 ) ) ( fib ( - n 2 ) ) ) ) ) ( fib 1 ) ( fib 2 ) ( fib 3 ) ( fib 2 ) ( fib 1 ) ( fib 2 ) ( fib 3 ) ( fib 4 ) ( fib 5 )
1= 1= 2= 1= 1= 1= 2= 3= 5=
(+?2=1
?1=1)
(+?2=1 (+?3=2 (+?4=3
?1=1) ?2=1) ?3=2)
Exerccio Elaborar um algoritmo em SCHEME para, dada uma lista de nmeros inteiros, devolver o somatrio dos nmeros da mesma. Exemplo: Sendo ( car L ) = 5 ( cdr L ) = ( 10 8 12 20 ) ( null ? L ) verifica se L vazia ( if ( exp_Booleana ) ( exp_verdadeira ) ( exp_falsa ) ( define ( somat L ) L = ( 5 10 8 12 20 ) ( somatrio L ) 55
49
( if ( null ? L ) 0 ( + ( car L ) ( somat ( cdr L ) ) ) ) ) Ex: 0 20 32 10 50 55
5() 5 ( 20 ) 5 ( 12 20 ) 5 ( 8 12 20 ) 5 ( 10 8 12 20 ) 5 ( 5 10 8 12 20 )
( + 20 0 ) = 20 ( + 12 20 ) = 32 ( + 8 32 ) = 40 ( + 10 40 ) = 50 ( + 5 50 ) = 55
PILHA
Que ativam processos iterativos ( define ( fib I n ) ( if ( < n 3 ) 1 ( fib I_aux n 1 1 ) ) ) ( define ( fib I_aux n f1 f2 ) ( if ( = n 3 ) ( + f1 f2 ) ( fib I_aux ( - n 1 ) ( + f1 f2 ) f1 ) ) )
8=
8=
( fib I 352 ) ( fib I 432 ) ( fib I 521 ) ( fib I 611 ) ( fib I 6 )
? ? ? ?=8
xY = z
8.3
Manipulao de listas em Scheme Lista so sequencias de zero ou mais valores. Em schieme uma lista representada por elementos entre parnteses. A lista vazia ou nula representada por ( ), ou seja, uma lista com zero elementos. E para informar ao interpretador que o contedo entre parntese uma lista, devese colocar um apstrofo (QUOT) parafraseando o abre parntese. Exemplo: ( ( ( Exemplo ) de ) ( uma lista ) em ( scheme ) )
50
operaes com listas ( define x ( ( ( exemplo ) de ) ( uma lista ) em ( scheme ) ) Linha de Comando Equivalente Resultado X x a prpria ( car x ) ( car x ) ( ( exemplo ) de ) ( car ( car x ) ) ( caar x ) ( exemplo ) ( cdr ( car x ) ) ( cdar x ) de ( cdr x ) ( cdr x ),( rest x ) ( ( uma lista )em( scheme ) ) ( car ( car ( cdr x ) ) ) ( caadr x ) uma ( cdr ( cdr x ) ) ( cddr x ) ( em ( scheme ) ) ( cons ( ( isto ) um ) x ) ( ( isto ) um ) ( ( exemplo ).. ( define x ( cons ( ( isto ) um ) x ) ) ( set ! ( cons ( ( isto ) um ) x ) ) ( length x ) 5 ( car ( cadddr x ) ) scheme
8.4
Usando a Notao Lambda esta anotao foi introduzida na linguagem para manter o padro da anotao do clculo lambda. Tambm usada para definir funes temporrias sem nome, internas a outras funes. Exemplos:
( define ( square x ) ( * x x ) ou ( define square ( lambda ( x ) ( * x x) ) )
Exerccios
1 - Construa uma funo para devolver o produto cartesiano entre duas listas representando valores, conforme exemplo: ( prod_cart ( 1 2 3 4 ) ( 5 6 7 8 9 )) ((15)(16)(17) (18) (25) (45) (48) recursivo e iterativo
51
2 - Dado um nmero inteiro qualquer, confeccionar uma funo para verificar se o nmero primo ou no : Ex.: ( primo ? 10 ) #f ( primo ? 11 ) #t
3 - Elabore uma funo para calcular o produto interno entre duas listas representando vetores de tamanhos iguais. Ex.: ( prod_int ( 1 2 3 ) ( 4 5 6 ) ) (579)
4 - Dada uma matriz qualquer, faa uma funo para calcular a determinante da mesma. Ex.: ( Determinante # ( 1 2 3 ) (2 3 1) (3 1 2) 6 + 6 + 6 - ( 27 + 1 + 8 ) 18 36 = -18 manipulao de vetores ( vector_ref #( 1 2 3 ) 2 ) 2 ( vector 1 2 3 ) # ( 1 2 3 ) ( vector_length # ( 1 2 3 )) 3 ( vector_set ! # ( 1 2 3 ) 2 5 ) # ( 1 5 3 )
5 - Confeccione uma funo em scheme para permutar dois elementos em uma lista Ex.: ( permuta 1 2 ( 1 2 3 )) ( 2 1 3 ) Recursivo Iterativo 6 - Faa uma funo scheme para ordenar uma lista, utilizando o mtodo da ordenao por seleo.
52
Ex.: ordenao por seleo Incio : d c a b 1 passo : a c d b permuta o menor elemento com o primeiro da lista 2 passo : a b d c permuta o menor da calda lista com o primeiro da calda da mesma. 3 passo : a b c d permuta o menor do cddr da lista com o primeiro do cddr da mesma e assim por diante. 7 - Faa um algoritmo em scheme para contar os elementos repetidos entre duas listas dadas l1 e l2. Recursivo Iterativo 8 Construa uma funo para devolver a unio, da teoria de conjuntos, entre duas listas dadas. Iterativo Recursivo 9 Elabore um algoritmo de ordenao para uma dada lista, usando o mtodo da insero. 10 Desenvolva uma funo para devolver a permutao de dois elementos de uma dada lista. Recursivo Iterativo 11 - Elabore um algoritmo de ordenao para uma dada lista, usando o mtodo da seleo. 12 - Construa uma funo em Scheme para ordenar uma lista dada, usando o algoritmo do Quick Sort.
53
9 Introduo Programao Orientada a Objetos

Inicialmente interessante dar significado s seguintes interrogativas: O que objeto? R.: Objeto => representa uma entidade do problema, a qual esto associados: - um conjunto de estados (caractersticas, atributos, etc...) - um conjunto de operaes que podem ser aplicadas a objeto Exemplo: Objeto tringulo Estados: medida dos lados, rea, classificao, etc... Operaes: desenvolver tringulo, preencher tringulo, rotacionar tringulo, etc Porque programao O.O. difere das programaes convencionais? R.: Programao Tradicional X P.O.O.: Programao O.O. difere fundamentalmente da Tradicional. P.O.O. trata o problema em termos dos objetos envolvidos e a Programao Tradicional trata os problemas em termos de suas funcionalidades (abrangem Top e Dowm). Programao O.O. mais facilmente descrita como programao por simulao. A metfora programao baseada na personificao dos objetos fsicos ou conceituais de algum domnio do mundo real em objeto no domnio do programa. Outra expresso que merece uma ateno especial : Orientado a Objeto, a qual intrinsicamente despronda de significado, ou seja, no possui, ainda classificao definida pela indstria de software, porm poderamos defini-la com auxlio de dicionrio, da seguinte maneira. - Dirigida para qualquer coisa que se possa pensar E no sentido computacional pode-se dizer que orientado objeto se define pelas seguintes propriedades: - Encapsulamento - Ocultamento de informaes/implementao - Reteno de estado - Identidade de objeto - Mensagens - Classe - Herana - Polimorfismo - Genericidade
54
9.1
Conceitos Bsicos
Objeto: um componente do sistema representado por algum dado privado e o conjunto de mtodos. Mtodo: a especificao (detalhadamento) de como uma mensagem implementada. Instncia: um objeto individual descrito por uma classe particular. Classe: uma descrio de um conjunto de objetos com caractersticas e atributos similares. Em outras palavras, so entidades que definem um padro de comportamento e estados para objetos a ela pertencentes . SuperClasse: uma classe contendo generalizaes de classes derivadas. Subclasse: uma especificao de uma SuperClasse, estendendo-a algumas caractersticas adicionais (comportamento e novos estados) . com
Herana: um mecanismo especfico pelo qual uma instncia de uma subclasse herda toda a representao e comportamento de suas super classes. Mensagem: um requisito enviado para um objeto, obtendo como resposta algum servio. Seletor: o componente de uma mensagem que unicamente especifica a operao requisitada. Receptor: instncia que recebe uma mensagem qualquer. 9.2 Caractersticas Importantes de P.O.O.
Os objetos comunicam-se na passagem de mensagem, o objeto que recebe uma mensagem chamado de receptor. Essas mensagens que obedecem a um certo protocolo, que definido como um conjunto de mensagens que podem ser enviadas para um determinado objeto. Exemplo: Objeto: CACHORRO Protoco LATIR lo: MOVIMENTA R DEITAR Estado EMOO s: PESO IDADE
Conjunto de mensagens que o objeto cachorro pode receber: LATIR, MOVIMENTAR, DEITAR; Qualquer outra o objeto no pode responder pois no pertence a seu protocolo. No caso do vdeo game: Objeto: BOLA Protocolo: POSIO ? DIREO ? MODIFICAR_POSI O ALM_BASE ? ATRS_BASE ? Estados: POSIO DIREO
c Atrs - Base ! Seletor Argumento
Bola
Receptor
Modificar - Posio : Nova - Posio
P.O.O. programao por classificao. No mundo real comum nos depararmos com estruturas hierrquicas definindo classes e objetos como por exemplo:
Seres Vivos Superclasse
Vegetal
Animal
Subclasse
Mamferos
Aves
56
Uma superclasse que no define comportamento de objetos inerentes do problema chamado de abstrata. Uma das caractersticas mais importantes de P.O.O. chamado POLIMORFISMO. Ele acontece quando uma mesma mensagem pode ser interpretada em diferentes caminhos por diferentes receptores (ou seja: receptores que pertencem a classes diferentes).
Exemplo: Objeto: CRCULO Protocolo: DESENHAR AJUSTAR POSICIONAR Estados: POSIO RAIO QUADRADO DESENHAR AJUSTAR POSICIONAR POSIO TAMANHO_LADOS
Logo as mensagens desenhar, ajustar e posicionar, possuem nomes iguais para os dois objetos, porm possuem cdigos distintos, caracterizando o polimorfismo.
Muitas vezes pensamos em objetos com caractersticas em comuns com outros objetos, como por exemplo: Polgono
Quadriltero Retngulo
Tringulo
Quadrado Vemos ento a hierarquia dos polgonos, comeando da classe Polgono derivando em Quadriltero e e Retngulo, que so subclasses de polgono. Desta forma, definidas, as instncias das subclasses herdam as caractersticas das superclasses. Isso em P.O.O. denominado programao com herana. A programao com herana de extrema importncia pelo motivo do reaproveitamento das definies semelhantes dos objetos que derivam das superclasses (reaproveitamento de cdigos).
57
10 Introduo Linguagem Smalltalk

Smalltalk mais do que uma simples linguagem de programao um completo ambiente de desenvolvimento de programas, integrado em um mtodo consistente, de modo que aplicativos como editar, compilador, debugger, checador de queda, utilitrios de impresso, sistema de janelas e gerenciador de cdigo origem esto embutidos no sistema. Geralmente, tais aplicativos esto associados a um sistema operacional, logo o smalltalk mais do que simplesmente uma linguagem de programao (melhor) pois elimina o crucialmente entre o S.O. e a programao, atravs da modelagem de tudo como um objeto. Tornar-se um produtivo programador em SMT requer muito mais que uma familiaridade com o mesmo. Programao em SMT requer o mnimo o entendimento dos seguintes assuntos; Os conceitos fundamentais da linguagem; isto : Objetos, Mensagens, classes, Heranas, ... A sintaxe e a semntica de SMT; Como interagir com o ambiente de programao SMT, para construir novas aplicaes (SMT uma linguagem interativa que favorece um aprender-fazendo). Conhecer as classes dos objetos fundamentais dos sistema, tais como: Magnitude, Collection, Graphical e classes de interface com o usurio. Projetar novas aplicaes SMT requer um conhecimento da capacidade do SMT. Programao em SMT muitas vezes dita programao por extenso; ou seja, novas aplicaes so construdas atravs da extenso da biblioteca de classes do sitema.
10.1 Objetos em SMT Tudo em SMT objeto, inclusive o prprio sistema. Componentes dos sistemas (compilador, debugger), elementos de dados (inteiros, booleanos e caracteres) e elementos grficos (reas retangulares, canetas de desenho e bitmaps), so todos tratados como objetos.
9.1.1 O que um objeto em SMT Conceitualmente, um objeto pode ser idealizado como um computador virtual com uma memria e instrues primitivas ou conjunto de operaes. Um objeto em memria dados privados ou estado que est retido dentro de um
objeto. Um objeto capaz de computao ele pode responder a qualquer mensagem previamente definida em seu interior. O conjunto de mensagens referido como protocolo de mensagens suportado pelo mesmo. Quando um objeto recebe um mensagem, ele deve primeiro decidir se ele "Entende" a mesma, e se deve responde-la. Ex.: Expresso em SMT umPonto Objeto x Mensagem Responde o valor da coordenada x do objeto umPonto
Expresso em SMT umPonto Objeto distanciaDe: mensagem outroPonto Parmetro Responde a distncia entre um Ponto e outroPonto umPonto
10.1.3 Encapsulamento Informaes Objetos em SMT encapsulam ambos procedimentos e dados. Este artifcio foi incorporado linguagem, devido ao sucesso obtido nas linguagens estruturadas no controle da complexidade de grandes programas, provido pelo encapsulamento. No controle da complexidade de grandes programas, deve-se particionar os programas em mdulos . Alm disso, deve-se esconder o mximo de informaes possvel dentro dos mdulos e minimizar a interface a usurios. Objetos em SMT apresentam dois pontos de vista, os quais so: um para usurios dos objetos e outro para quem implementa os mesmos. Costuma-se chamar estes pontos de vista de: vista externa e vista interna respectivamente. A vista interna descreve a representao e os algoritmos que implementam os mtodos dos objetos. A vista externa o visual do objeto visto por outros objetos. Ex.:
umPonto umPonto
x y
A vista externa ou protocolo de mensagens suportado pelo objeto umPonto.

A separao entre vista interna e vista externa de um objeto fundamental na filosofia de programao embutida em SMT. Para usar um objeto, necessrio entender somente um protocolo, ou seja, vista externa.
10.1.4 Objetos Literais Certos tipos de objetos podem ser descritos literalmente em SMT. Por exemplo, literais so usados para descrever nmeros, smbolos, caracteres, strings e arrays. Smalltalk 34 -17.62 1.5 -e 'uma string' # solues $c #(-25 'uma string' $c) #(10 100 150) C 34 -17.62 1.5-e "uma string" 'c' { 10 100 150} Comentrios inteiro 34 p.f. -17.62 p.f. 0.0015 deforma exp smbolo com o nome solues(no coexistem) caracter c array com 3 obj. No homogneos array com obj homogneos
10.2 Mensagens Os componentes de uma mensagem so chamados de: RECEPTOR, SELETOR e ARGUMENTOS, respectivamente. Ex: 1+5 O inteiro 1 o receptor da mensagem, + o seletor que unicamente identifica qual operao ser escolhida e 5 o argumento. O tratamento desta operao em relao a programao tradicional diferente: Tradicional 6
+ 1 operador 5 operandos
O.O. 6
1 +5
60
SMT suporta trs tipos primitivos de mensagens, conhecidas, UNRIA, BINRIA e KEYWORD. 9.2.1 Mensagens Unrias
como:
So aquelas mensagens que na sua expresso no possui nenhum argumento. Ex: 'letras minsculas' asUpperCase #(4 3 2) reversed $c asciiValue 38 asCharacter 10.2.3 Mensagens Keyword So mensagens com um ou mais argumentos. Estas mensagens so caracterizadas por possuir sempre o caracter " : " (dois pontos) como parte do nome do seletor da mesma. Ex: 'caracter na posio' at: 4. 'uNIT' at: 1 put: $U. 'copia parte da string' copyFrom: 7 to: 18. #(1 (2 3 ) 4 5 ) includes: 1. 10.2.4 Mensagens Binrias So mensagens com somente um argumento e 1 ou 2 caracteres especiais com o seletor. Ex: 50 + 100. 'abc''~= 'ghi'. #(1 2 3),(4 5 6). 'concatena', 'string'. 10.2.5 Outros Tipos de Mensagens
10.2.5.1
Mensagens Aritmticas
So, na maioria das vezes mensagens binrias.
61
Ex: 5 * 7 Multiprogramao 5 // 2 Diviso inteira 4 \\ 3 Resto da Diviso 2 / 6 Diviso racional (resposta na forma reduzida). A avaliao de expresses feita da esquerda para direita, no havendo precedncia entre operadores. Exemplo: 5 - 3 * 7 (resultado = 14) 10.2.5.2 Mensagens Dentro de Mensagens Parentizada ('Tamanho' size) + 4 = 11 ( ('trs' size) + (#(1 2 3) size)) (2 factorial) negated = -2 (15 gcd : (3//3)) (5 between: 1 and: ((3 sqwared) + 4)) = true ((4 factorial) gcd: (4*6)) = 24
Expresso 'TAMANHO' size + 4 'trs' size + #(1 2 3) size 2 factorial negated 15 gcd : 3//3 5 between: 1 and: 3 sqwared + 4 4 factorial gcd: 4*6
Precedncia das Mensagens 1- Parentizada 2- Unria (avaliadas da esquerda para direita) 3- Binria (avaliadas da esquerda para direita) 4- KeyWord 10.2.5.3 Mensagens em Cascata
uma maneira concisa de especificar que multiplas mensagens sero enviadas para um mesmo receptor. As vrias mensagnes so separadas por ; (ponto e vrgula). Ex: umArray at:1 put:3. umArray at:2 put:8. umArray at:2 put:5. ou escrevendo em cascata umArray at:1 put:3 ; umArray at:2 put:8 ; umArray at:2 put:5. O resultado de uma cascata de mensagens o resultado da ltima mensagem. Para verificar o resultado de todas as mensagens a ltima mensagem deve ser yourself.
62
Ex: umArray at:1 put:3 ; ... ; yourself. 10.2.6 Variveis Temporrias Devem ser declaradas na primeira linha de uma srie de expresses, delimitadas por barras verticais (pipes). Devem iniciar com letras minsculas e podem armazenar qualquer objeto. Ex: | aux indice vetor | vetor := #(3 4 5 6). indice := 1. vetor size timesRepeat: [ aux := vetor at:indice. vetor at: indice put:aux factorial. indice := indice + 1. ]. ^vetor
10.2.7 Sintaxe das principais mensagens Mensagens para comparao de objetos < "menor"; > "maior"; <= "menor ou igual"; >= "maior ou igual"; = "igual"; ~ = "diferente". Teste de Objetos: isUpperCase " minsculo"; odd " mpar"; isVowel " vogal". Expresses condicionais ifTrue: , ifFales: e ifTrue:ifFalse Exemplo: <expr.boll.> ifTrue:[bloco de programa] <expr.boll.> ifFalse:[bloco de programa]
63
ou <expr. boll.> ifTrue: [bloco de programa] ifFalse: [bloco de programa]. Expresses booleanas or: , and: , not: , ... , mensagens de comparao Exemplo: <expr. bool.> or: [bloco booleano]. <expr. bool.> and: [bloco booleano]. <expr. bool.> not: [bloco booleano]. Mensagens de repetio WhileTrue: , whileFalse: , to: do: , ... , timesRepeat:. Exemplo: <expr. bool.> whileTrue: [bloco de programa]. <expr. bool.> whileFalse: [bloco de programa]. valor.inicial to: valor_final do: [ : variavel_de_controle | bloco de programa]. valor_numrico timesRepeat:[bloco de programa].
10.2.8 Iteradores Os iteradores so mensagens para serem enviadas para objetos da classe Collection (somente) as quais servem como comandos de 'loop'. De forma que, para cada elemento pertencente coleo em questo, a mesma executa um bloco de programa em SMT e est divididas em quatro tipos diferentes, de acordo com o tipo de resultado retornado, so elas: O Iterador do: Este iterador no retorna nenhum tipo de objeto (nil). Exemplo: "Contagem do nmero de caracteres vogais dentro de uma string" | vogais | vogais := 0. uma string contendo vogais 'do : [char | char isVowel ifTrue: [vogais := vogais + 1]]. ^vogais O Iterador select
Retorna um objeto da mesma classe do objeto que est recebendo a mensagem, logo o resultado tambm uma coleo. - Coleo de objetos que satisfazem uma condio booleana interna ao bloco executado. Exemplo: "Conta o nmero de consoantes internas a um array de caracteres" ^(# ($a $b $c $d $e $f $g) select: [:x | x isVowel not) size. O Iterador reject Da mesma forma que o select: este iterador retorna um objeto da mesma classe do receptor da mensagem. Porm, agora contendo aqueles elementos que no satisfazem a expresso booleana. Exemplo: "Retorna aqueles objetos cujo valor dele 4 potncia supera o seu fatorial" ^# (1 2 3 4 5 6 7 8 9) reject: [: i | i * i * i * i < i fatorial ]. O Iterador Collect Este iterador retorna dentro do objeto coleo de resposta todos os resultados de execuo do bloco de programa. Exemplo: "Devolve, para um array se inteiros o quadrado dos nmeros pares o dobro dos mpares" ^#(1 2 3 4 5 6 7 8 9) collect : [: x| x old ifTrue: [x * 2] ifFalse: [x * x]].
Lista de Exerccios 1 - Comente com suas palavras sobre programao por classificao. 2 - Cite as principais vantagens da programao com herana(Mltipla / Simples). 3 - Diga onde voc enxerga encapsulamento em POO.
65
4 - Para cada expresso abaixo parentize-a de acordo com a ordem de execuo de cada mensagem (numerando-as) e diga: - Qual o tipo de cada mensagem - Qual o receptor de cada mensagem - Qual o seletor de cada mensagem - Qual a classe do receptor - Quais so os parmetros de cada mensagem - Qual o resultado final A) #(5 7 8 10) at:2 + 'vetor' size-4 B) #(5 6 7) at:5 factorial //$t ascciiValue C) 2 + 2 * 3.25 // 2 \\ 10. D) 'str' size between:5 and: 10 exp //10e3 obs..: Se em algum caso acima a expresso acusar erro, parentize-a de forma que corrija o erro e responda os itens.
5 - Faa utilizando um iterador, uma forma para calcular a mdia aritmtica dos nmeros contidos em um array qualquer (o array no contm somente nmeros, considerar s os nmeros). 6 - Faa um algortmo, para dada uma string pertence primeira. 7 - Faa um algortmo para, dado um array contendo objeto diversos (de diversas classes), devolver um outro array contendo vrios outros arrays de forma que nestes arrays internos contenham somente objetos da mesma classe e colocar o nome da classe dos objetos contidos no array interno, na 1 posio dos mesmos. Ex: #('str' 2 #(10 20) $e $b 5) retornar:#(#('String' 'str') #('smallInteger' 2 5) #('Array' #(10 20)) #('character' $e $b)) 10.3 Implementao de Classes e Mtodos 9.3.1 Classes Soluo de problema usando smalltalk envolve classificao de objetos de acordo com sua similaridades e diferenas. Ex: #(Maria Joana) class (Instncia da classe Array) uma string (lass (Instncia da classe string) Turtle class (Instncia da classe Pen)
66
Variveis internas de um objeto so chamadas variveis de instncia. Por exemplo: objetos da classe Fraction tem as variveis de instncia numerator edenominador. 10.3.3 Mtodos Mtodos so cdigos em smalltalk, o algoritmo que determina todo comportamento e performance do objeto quando uma mensagem enviada para um objeto, um mtodo avaliado e um objeto retornado como resultado.
Ex1:
(1/7) numerator Quando esta mensagem enviada, o seguinte mtodo executado: numerator ^numerator Ex2: (2/3) * (5/7) Mtodo executado: *aNumber ^(numerator * aNumber numerator) / (denominator * aNumber Denominator). Na construo de mtodo sempre a primeira linha define o nome do mesmo e na frente do nome vem seus argumentos (quando houver) a partir da segunda linha vem o desenvolvimento do mtodo. 10.3.4 Class Herarchy Brauser Para programar em SMT pode-se usar uma janela especial chamada Class Herarchy Brauser. Ela dotada da capacidade de mostrar e modificar definies de classes e mtodos exigentes e ainda criar novas classes com seus mtodos. Pode ser acessada via menu do sistema ou da forma que segue abaixo: Class Herarchy Brauser new Open on: (Array with: Integer with: Fraction with: String ).
Painel de Escolha
Painel de Mtodos Criado por Painel de Marcelo Fernandes dos Santos Classes Painel de 67 Variveis Painel de Cdigo
Class Hierachy Browser Fraction Instance Integer Class String Vars
10.3.5 A varivel especial self Adicionando o seguinte mtodo na classe Fraction, temos: Fraction responde a parte fracionria do nmero ^self self truncated onde a palavra self representa o objeto que o receptor da mensagem. Ex: (22/7) fraction (2/3) fraction 10.3.6 Criao de novos objetos e o objeto especial nil A maneira j conhecida de criar objetos, at ento conhecida a literal, por exemplo: uma ,string (1/3) Mas como classes tambm so objetos, logo podem receber mensagens tambm. O caminho mais prtico de se criar objetos enviando mensagens para classes tais como: Array new: 10.(cria um objeto da classe Array com 10 por onde todas as posies contm o objeto especial nil) Array new (cria um objeto da classe Array). Pen new Date Today Time now. O objeto nil pertence a classe UndefinidObject. Ele uma varivel de instncia de todo novo objeto.
68
10.3.7 Variveis de Instncia Objetos podem conter ambas named e indexed variveis de instncia. Variveis de instncia named so acessadas pelo nome, tal como numerator para objetos fraction. J a indexed so identificadas por inteiros iniciando com 1, tal como : localizao at:2; parts at:5 put: $y. 10.3.8 Recurso Exemplos: Fatorial devolve o fatorial do receptor self > 1 ifTrue: [^(self 1) fatorial * self]. Self < 0 IfTrue: [^self erros: nmero negativo]. ^1. Fibonacci devolve o n-esimo termo da sequencia de fib. Onde n o receptor ^self < 3 ifTrue: [1.] ifFalse[(self 1) fibonacci + (self 2) fibonacci.].
Exerccios 1 - Faa um Mtodo em SMT para calcular a mdia dos nmeros contidos em um Array de inteiro, os quais estejam entre dois limites dados. Ex.: #(1 2 3 4 5 6 7 8 9) mediEntre: 4 e: 8
2 - Desenvolva um Mtodo para calcular o n-simo nmero da seqncia abaixo: 1 1 2 6 24 120 720 ... a qual dada pela seguinte frmula ni = ni-1 * i -ni -2 * (i-2) 5 serie 24
69
10.3.9 Criao de classes completas Suponhamos a proposta de construirmos uma classe para os nmeros Complexos. Number subclass: #Complexo InstanceVariableNames: realPart imaginaryPart. ClassVariableNames: . class Methods novoComplexo: parteReal e: parteImaginaria retorna uma instncia inicializada da classe complexo |umComplexo| umComplexo := Complexo new. umComplexo realPart: parteReal; imaginaryPart: parteImaginaria ^umComplexo instance Methods realPart imaginaryPart ^realPart ^imaginaryPart realPart: realValue imaginaryPart: imaginaryValue realPart := realValue imaginaryPart := imaginaryValue + umComplexo | realSum imagSum | realSum := realPart + umComplexo realPart. ImagSum := imagPart + umComplexo imaginaryPart. ^Complexo novoComplexo: realSum e: imagSum
Exerccio Construa o mtodo da multiplicao, *, para um objeto da classe Complexo.

( a + bi ) * ( c + di ) ac + adi + bci + bd ( ac + bd ) + ( ad + bc ) i
Ex:
10.4 Descrio da Classe Collection A classe collection uma das mais importantes classes primitivas do SMT.
Arquitetura da Classe Collection Bag IndexedCollection FixedSizeCollection Array Bitmap Compiled Method File Control Black Interval String Simbol Ordened Collection Process SortedCollection Set Dictionary Identity Dictionary MethodDictionary SystemDictionary SimbolSet As classes derivada da classe Collection suportam protocolos para : 1 - Efetuar iteraes sobre elementos de uma coleo : Ex.: uma_colecao do : [ : i | ... ] uma_colecao select : [ : i | ... ] uma_colecao reject : [ : i | ... ] uma_colecao collect : [ : i | ... ] 2 - Procurar por um elemento 3 - Adicionar ou remover elementos 4 - Acessar e alterar elementos
CLASSE Bag IndexedCollection FixedSizeCollection Array ByteArray Interval String Symbol SortedCollection ORDENAO NO SIM SIM SIM SIM INTERNO SIM SIM INTERNO TAMANHO FIXO NO SIM SIM SIM SIM SIM SIM NO ACEITA REPETIO SIM SIM SIM SIM NO SIM SIM SIM CHAVE DE ACESSO INTEGER INTEGER INTEGER INTEGER INTEGER INTEGER INTEGER INTEGER CLASSE DOS COMPONENTES Q.Q. Q.Q. SMALINTEGER NUMBER CHARACTER CHARACTER Q.Q. 71
Dictionary
NO
NO
NO
CHAVE
Q.Q.
11 Problema Proposto
Vdeo Game
Object Video Comp Brick MovingComp . x,y . direo . velocidade Wall VideoGame . laterais . pontos . jogador . parede . ambiente
.
Ball - Drawing Mode Constants - Color Constants - Win Constants
Padde
posmouse pane . pen . pedal . bola

.
Mtodos de Instncia de Brick Mtodos de Classes de MovigComp new : dir posx : px poy : py vel : v | novo | novo := self new novo direcao : dir; posicaox : px; posicaoy : py; velocidade : vel. ^ novo Mtodos Instncia da Classes MovigComp direcao ^ direcao direcao : dir direcao := dir posicao x ^x posicaox : px x := px posicao y ^y posicaoy : py y := py velocidade ^ velocidade
velocidade : vel velocidade := vel.
73
Apndice A 1 Programao Orientado a Objeto

A expresso orientado a objeto intrinsecamente desprovida de significado. * Objeto - Tudo o que apresentado ou capaz de ser apresentado aos sentidos. * Orientado a Objeto - Dirigido para qualquer coisa em que se possa pensar. Uma linguagem ou ambiente orientado a objeto se ela possui a maior parte das seguintes propriedades: * Encapsulamento * Ocultamento de informao/ implementao * Reteno de estado * Identidade de objeto * Mensagens * Classes * Herana * Polimorfismo * Genericidade Para prosseguirmos com as explicaes iremos utilizar-se da aplicao Homindio em miniatura movendo-se em uma grade na tela, como mostrado abaixo. OBS: A sintaxe e semntica no faz parte de nenhuma linguagem, ela usada apenas para explicao.
Descrio do problema: O Homindio simplesmente ter de navegar por um caminho tortuoso formado por blocos quadrado posicionados de maneira a formar um caminho com a largura de um bloco, indo desde o quadrado marcado INCIO at o quadrado marcado FIM.
Para isso temos duas classes, a classe GRADE e a classe HOMINDIO, as quais utilizaremos para explicaes da Programao Orientada a Objeto.
1.1
Encapsulamento
um conceito quase to antigo quanto o prprio software. Os programadores observaram que padres similares de instrues apareciam vrias vezes dentro de um mesmo programa e perceberam que esses padres repetidos poderiam ser amontoados em um campo do programa e invocados atravs de um nico nome a partir de vrios pontos diferentes no programa principal. Desta forma nasceu a to conhecida sub-rotina utilizada em programao estruturada. O encapsulamento em Orientao a Objeto tem uma finalidade similar quela da sub-rotina. Mas estruturalmente ele mais complexo. Resumindo: Encapsulamento o agrupamento de idias relacionadas em uma unidade e o encapsulamento orientado a objeto o agrupamento de procedimentos em torno de dados. Um objeto consiste em um conjunto de mtodos e em um conjunto de variveis. Cada mtodo um procedimento publicamente visvel, o que significa que ele pode ser chamado por outros objetos. Variveis so usadas internamente por um objeto para guardar informaes. O acesso s variveis e sua atualizao so feitos pelos mtodos do objeto. Cada varivel est relacionada a um objeto, o que significa que nenhum outro objeto poder acess-la diretamente. Se um outro objeto precisar das informaes contidas naquela varivel, ter de apelar para um dos mtodos do objeto. Como somente os mtodos do objeto podem ler e atualizar as variveis do objeto, esses mtodos formam um anel protetor ao redor do ncleo central de variveis. Podemos designar cada mtodo e cada varivel do objeto sendo como: * Pblico - Visvel aos outros objetos. * Privativo - Visvel somente dentro do objeto. 1.2 Ocultamento de Informao e de Implementao
Podemos enxergar uma unidade encapsulada de fora ( viso pblica ) ou de dentro ( viso privativa ). O resultado de um bom encapsulamento a supresso na viso pblica de uma variedade de detalhes para serem vistos na viso privativa. Essa supresso assume duas formas: * Ocultamento de informao - Implica que as informaes dentro da unidade no podem ser vistas de fora da unidade. * Ocultamento de implementao - Implica que os detalhes da implementao dentro da unidade no podem ser vistos de fora da unidade O ocultamento de informao contm alguma informao privativa inacessvel de fora. Um exemplo a direo para a qual est voltado o Homindio. De fora do objeto
podemos mudar essa informao ( talvez atravs do mtodo vira-esquerda ), mas no podemos determinar seu valor. O encapsulamento freqentemente revela informaes, mas esconde a implementao. Por exemplo, embora o objeto Homindio nos informe qual sua localizao ( via mtodo Localizao ), nos no sabemos como o objeto armazena sua localizao internamente. A direo do Homindio um exemplo no apenas de ocultamento de informao, mas tambm de ocultamento de implementao. O ocultamento de informao e de implementao uma poderosa tcnica para domesticar a complexidade do software. Isso significa que o objeto aparece como uma caixa-preta a um observador externo. 1.3 Reteno de Estado
A terceira abstrao da orientao a objeto refere-se capacidade de um objeto de reter seu estado. Quando um mdulo procedural tradicional ( funo, subprograma, procedimento e etc), retorna ao seu chamador mdulo morre, deixando apenas seu resultado. Quando o mesmo mdulo chamado novamente ele no se lembra de nenhum valor anterior, como se ele estivesse sendo executado pela primeira vez, ou seja, ele no guardou nenhum valor do processamento anterior. Mas o objeto, como o Homindio, tem conscincia de seu passado. Ele retm informaes dentro de si mesmo por um tempo indefinido. Por exemplo, um chamador de um objeto pode dar a ele um item de informao, e esse chamador - ou qualquer outro - pode pedir ao objeto que lhe fornea a informao novamente. Em outras palavras um objeto no morre quando termina sua execuo, ou seja, ele permanece de prontido, preparado para entrar em ao novamente. Por exemplo, o Homindio retm indefinidamente seu conhecimento do quadrado no qual ele se encontra e a direo para a qual ele est voltado. Encapsulamento Orientado a Objeto, Ocultamento de Informao e de Implementao e Reteno de Estado constituem o ncleo da orientao a objeto.
1.4
Identidade de Objeto
Identidade de objeto a propriedade segundo a qual cada objeto (independente de sua classe ou estado atual) pode ser identificado e tratado como uma entidade de software distinta. H algo nico ligado a um dado objeto que distingue de todos os outros objetos. Esse algo nico proporcionado pelo mecanismo identificador do objeto, que explicaremos atravs da anlise de uma linha do cdigo do homindeo: Var hom1:HOMINDEO := HOMINDEO.new A parte do lado direito dessa linha cria um novo objeto (da classe HOMINDEO), Coloca-na-grade que mostramos na figura 1.6. Note o identificador do objeto, que para o objeto da figura o nmero 102237. O identificador anexado a um objeto quando ele Objeto Vira-esquerda criado.
Exibe Vira-direita Avana Frente-parede Localizao Dir loc 102237 Manipulador de objeto 3
Duas regras se aplicam aos identificadores: O mesmo identificador permanece com o objeto por toda sua existncia, independente do que possa acontecer durante esse tempo. Dois objeto no podem Ter o mesmo identificador. O lado esquerdo da linha de cdigo a declarao Var hom1:HOMINDEO. Esta uma declarao normal de programa que d um nome que tenha significado para o programador para uma palavra de memria. (figura 1.7).
Hom1 102237 Vira-esquerda Exibe Vira-direita Avana Frente-parede Localizao Dir loc 102237 Coloca-na-grade
Ningum v o identificador do objeto (102237), apenas trabalha com a varivel hom1. Esta varivel guarda o endereo de memria de hom1. Executado uma outra linha similar de cdigo: Var hom2:HOMINDEO := HOMINDEO.new Isso criar um outro objeto com o identificador, digamos, 142857, e armazenar esse identificador na varivel hom2( figura 1.8).
Hom1 142857 Vira-esquerda Exibe Vira-direita Avana Frente-parede Localizao Dir loc 142847 Coloca-na-grade
Para melhor evidenciar, escreveremos uma outra declarao de atribuio assim: Hom2 := hom1 A varivel hom2 aponta para o mesmo endereo de memria de hom1 (102234). S que, no conseguimos acessar mais o endereo de hom2, ou seja, o endereo de hom2 foi perdida. A idia de dar a cada objeto sua prpria identidade atravs de um identificador parece inofensiva. Surpreendentemente, no entanto, essa simples idia causa uma profunda mudana na maneira como projetamos e construmos software orientado a objeto. 1.5 Mensagens
Um objeto requisita um outro objeto para executar uma atividade atravs de uma mensagem. Uma mensagem tpica tambm direciona algumas informaes de um objeto para outro. Ela a maneira pela qual um objeto emissor (ob1) dirige para um objeto alvo (ob2) uma solicitao para que o objeto (ob2) aplique um de seus mtodos. 1.5.1 Estrutura de uma Mensagem Uma mensagem composta por vrias partes sintticas, cada uma da quais importante sua prpria maneira no projeto orientado a objeto. Para que o objeto (ob1(emissor)) envie uma mensagem sensata ao objeto (ob2(alvo)), o ob1 tem saber trs coisas: 1.O identificador de ob2. O ob1 manter o identificador em uma varivel. 2.O nome do mtodo de ob2 que ob1 deseja executar. 3. Quaisquer informaes suplementares (argumentos) que ob2 necessitar na execuo de seu mtodo. 1.5.3 Argumentos de uma Mensagem Assim como as antigas sub-rotinas, muitas mensagens passam e retornam argumentos para trs e para frente. Por exemplo, se fizssemos com que o mtodo denominado avana retornasse um sinalizador contendo o resultado do avano, ento teramos:
Arg.entrada
arg.sada
Hom1.avana (nm-de-quadrados; avana-ok) Objeto-alvo nome do mtodo assinatura
mensagem Uma mensagem para um objeto-alvo consiste em duas partes: o nome do mtodo e a assinatura.A assinatura uma lista de argumentos de entrada (para o objeto-alvo) ,seguida de uma lista de argumentos de sada (do objeto-alvo). Os argumentos de uma mensagem refletem um outro contraste fundamental entre software orientado a objeto e software tradicional. Em um ambiente orientado a objeto puro (como aquele da Smaltalk), os argumentos das mensagens no so dados; eles so identificadores de objetos. Argumentos de mensagem so, portanto, como objetos em p. Notao grfica de uma mensagem - hom1.avana(num-de-quadrados;avana-ok) do programa homindeo sendo executada: Contm um identificador como o 123432
nm-de-quadrados
Homindeo
hom1 avano-ok
avana
contm um identificador como o 664730 Para ilustrar esse ponto mostramos em notao grfica uma mensagem hom1.avana(nm-de-quadrados;avana-ok) do programa homindeo sendo executada. Se tivssemos tirado um instantneo do programa homindeo enquanto ele estava executando essa mensagem, por exemplo: Nm-de-quadrados Avana-ok contm 123432 contm 664730
6
O nmero 123432 pode ser o identificador do objeto da classe INT que normalmente consideramos com o inteiro 2, e 664730 pode ser o identificador do objeto da classe BOOL que normalmente consideramos como o valor lgico true. 1.5.4 Os Papis dos Objetos nas Mensagens Um objeto pode ser: emissor de uma mensagem. alvo de uma mensagem. Apontado por uma varivel dentro de um outro objeto. Apontado por um argumento passado ou retornado de uma mensagem.
Um dado objeto pode desempenhar qualquer um desses papis em algum instante de suavida. Um mtodo de um objeto pode enviar mensagens para os objetos apontados pelas variveis privativas de objeto. Na orientao a objeto pura, no h necessidade de dados, porque os objetos podem fazer todas as tarefas de software necessrias dos dados. E em Smaltalk que uma linguagem pura , no h realmente dado algum! Durante o processamento, h apenas objetos apontando para outros objetos (via variveis) e comunicando-se com outros objetos passando manipuladores para trs e para a frente, para outros objetos.No entanto, em C++ (que uma linguagem mista tanto orientada a dados e funes com orientada a objeto), os argumentos podem ser ponteiros para qualquer coisa. Se o seu cdigo C++ for to puro quanto o smaltalk, ento todos os seus ponteiros sero ponteiros para objetos. Mas se forem misturados objetos e dados no seu programa, ento alguns dos seus argumentos podero ser simples dados ou ponteiros para dados. 1.5.5 Tipos de Mensagem H trs tipos de mensagem que um objeto pode receber: Mensagem informativa: uma mensagem para um objeto fornecendo lhe informaes para que ele prprio se atualize. ( conhecida tambm como uma mensagem de atualizao (update), para frente (forward) ou de empilhar (push)). Ela uma mensagem orientada para o passado, pois usualmente informa ao objeto sobre o que j aconteceu em algum lugar. Um exemplo de uma mensagem informativa hom1.coloca-na-grade(grade, inicquadrado;colocao-ok). Essa mensagem informa ao objeto homindeo qual o quadrado inicial no qual ele foi colocado.
Mensagem interrogativa: uma mensagem para um objeto pedindo que ele revele alguma informao sobre si prprio. ( conhecida tambm como uma mensagem de leitura (read), para trs (backward) ou de desempilhar (pull) ). um mtodo orientado para o presente, pois solicita do objeto alguma informao atual. Um exemplo de uma mensagem interrogativa hom1.localizao, que pede ao homindeo que nos diga em que quadrado ele est no momento. Esse tipo de mensagem no muda coisa alguma; em vez disso, usualmente ela uma consulta sobre a parte do mundo que o objeto-alvo representa. Mensagem imperativa: uma mensagem para um objeto pedindo que ele faa alguma ao sobre si mesmo, sobre um outro objeto ou mesmo sobre o ambiente em que se encontra o sistema . (Isso tambm conhecido como mensagem de fora (force) ou de ao (action) ). uma mensagem orientada ao futuro, pos pede ao objeto que execute alguma ao em um futuro imediato. Um exemplo de uma mensagem imperativa hom1.avana, que faz o homindeo se mover para frente. Esse tipo de mensagem freqentemente faz com que o objeto-alvo execute algum algoritmo importante para saber o que fazer. 1.6 Classes
Uma classe o estncil (ou matriz) a partir do qual os objetos so criados (instanciados). Cada objeto tem a mesma estrutura e comportamento da classe da qual ele for instanciado. Se o objeto ob pertence a classe C, dizemos que ob uma instncia de C. A distino entre uma classe e um objeto o seguinte: Uma classe o que projeta e programa. Objeto o que se cria (a partir de uma classe) durante o processamento. Todos os objetos criado de uma classe tm a mesma estrutura, em particular, seus mtodos so idnticos, e idnticas tambm as variveis. Cada objeto (instncia) de uma classe tem sua prpria cpia do conjunto de mtodos e conjunto de variveis que ele necessita. As cpias do conjunto de mtodos que pertencem a diversas instncias de uma classe so absolutamente idnticas. Como cada conjunto de mtodos puramente cdigo procedural, um nico conjunto pode ser compartilhado por todos os objetos. Assim, em princpio cada objeto tem seu prprio conjunto de mtodos, mas na prtica (para economizar espao) eles compartilham a mesma cpia fsica.
Por outro lado, embora os identificadores e as variveis de cada objeto sejam idnticos em termos de estrutura de objeto para objeto, eles no podem ser compartilhados entre objetos. A razo,
naturalmente, que eles devem conter diferentes valores durante o processamento.
1.7
Herana
A herana representa outra maneira importante pela qual a orientao a objeto se distancia das abordagens tradicionais de sistema. Ela, efetivamente, permite que se construa o software de maneira instrumental do seguinte modo: primeiro, criam-se classes para atenderem ao caso mais direto (ou geral). Depois, para tratar dos casos especiais, adicionam-se classes mais especializadas que herdam da primeira classe. Essas novas classes sero habilitadas a usar todos os mtodos e variveis ( mtodos e variveis de classe e de instncia) da classe original. Existem dois tipos de heranas: HERANA NICA aquela em que cada classe tem apenas uma superclasse direta. Exemplo: Vamos supor que temos uma classe AVIO em uma aplicao de aviao. AVIO pode ter definido em si um mtodo de instncia denominado curva e dentro dele uma varivel de instncia denominada curso. A classe AVIO trata das atividades ou informaes pertinentes a qualquer tipo de mquina voadora. Porm, h tipos especiais de avies que executam atividades especiais. Ento, podemos definir uma nova classe -PLANADOR- que herdar de AVIO suas propriedades alm de ter outro mtodo de instncia denominado soltar_cabo e uma varivel de instncia denominado se_conectado. Vamos analisar um pequeno trecho de cdigo orientado a objeto a partir das classes AVIO e PLANADOR. var av : AVIO.new; var pl : PLANADOR.new; av.curva (novo-curso; curva-ok); pl.soltar_cabo; pl.curva (novo-curso; curva-ok); av.soltar_cabo; HERANA MLTIPLA aquela em que cada classe pode ter um nmero arbitrrio de superclasses diretas. Este tipo de herana converte a rvore de heranas com heranas nicas em um reticulado de heranas, ela traz alguns problemas difceis para o projeto, incluindo a possibilidade de uma superclasse herdar mtodos (ou variveis) conflitantes de seus
mltiplos ancestrais ( mtodos conflitantes tm o mesmo nome e a subclasse herdeira no pode saber facilmente qual deles herdar). Apesar de tudo , como a herana mltipla criar estruturas complexas e incompreensveis, voc dever usar herana mltipla com muito critrio - com muito mais critrio do que com a herana nica. Exemplo: Suponhamos que queiramos criar uma classe denominada AVIO-DEPASSAGEIROS, e que tenhamos criadas outras duas classes: AVIO e VECULOS DE PASSAGEIROS. A classe AVIO-DE-PASSAGEIROS poder herdar tanto de AVIO como de VECULOS-DE-PASSAGEIROS. 1.8 Polimorfismo
A palavra polimorfismo deriva de duas palavras gregas que significam, respectivamente, muitas e formas. Qualquer coisa que seja polimrfica tem, portanto a habilidade de assumir vrias formas. Os livros-textos orientados a objeto tm duas definies de polimorfismo: 1. Polimorfismo o dispositivo pelo qual o nome de um nico mtodo pode ser definido sobre mais de uma classe e pode assumir diferentes implementaes em cada uma dessas classes. 2. Polimorfismo a propriedade pela qual uma varivel pode apontar para (manter o identificador de ) objetos de diferentes classes em instantes diferentes. Vamos supor que temos uma classe POLGONO, que representa o tipo de forma 2-d que a figura 1.20 exemplifica. Em POLGONO podemos definir um mtodo denominado rea. Esse mtodo precisaria de um algoritmo razoavelmente complexo porque ele teria de servir para qualquer um dos polgonos de formas irregulares da Fig.1.20. Agora, vamos acrescentar mais algumas classes - como TRINGULO, RETNGULO E HEXGONO - que so subclasses de (e, portanto, herdam de) POLGONO.
10
Figura 1.20 Alguns polgonos planos.
Note que na fig.1.21 as classes TRINGULO e RETNGULO tambm tm mtodos denominados rea de POLGONO - quer dizer, calcular a rea total da superfcie limitada pela forma.
Figura 1.21 Polgono e suas trs subclasses. No entanto o projetista/programador de rea para RETNGULO escreveria o cdigo para seu mtodo de uma maneira muito diferente do cdigo de rea para POLGONO. Por qu? Porque a rea de um RETNGULO simplesmente comprimento * largura; o cdigo para o mtodo rea de RETNGULO, consequentemente simples e eficiente. Assim se escrevermos um cdigo que manda a seguinte mensagem para um objeto chamado de forma-duas-d: forma-duas-d.rea podemos no saber qual o algoritmo que ser usado para o clculo da rea. A razo que podemos no saber exatamente a que classe pertence forma-duas-d. H cinco possibilidades: 1. Forma-duas-d uma instncia de TRINGULO. 2. Forma-duas-d uma instncia de RETNGULO. 3. Forma-duas-d uma instncia de HEXGONO. 4. Forma-duas-d uma instncia de POLGONO.
11
5. Forma-duas-d uma instncia de uma classe C (por exemplo CLIENTE) que no nenhuma das quatro classes acima. Como C no tem um mtodo denominado rea definido dentro dele, o envio de uma mensagem rea resultar em um erro de compilao. Voc pode achar estranho que um objeto possa no ter a informao sobre a classe exata do objeto-alvo para o qual esta enviando uma mesagem. No entanto, tal situao bastante comum. Na linha final do cdigo, a seguir, durante a compilao no podemos saber para que classe de objeto p apontar durante o processamento. O objeto real para o qual ser apontado ser determinado por uma escolha do usurio no ltimo instante.( no comando if). Var p: polgono Var t: tringulo:=tringulo.new; Var h: hexgono:=hexgono.new; ......... if usurio diz ok then p:= t else p:= h endif; ......... p.rea; // aqui p pode se referir a um //tringulo ou hexgono .......... Note que no trecho de cdigo orientado a objeto mostrado, no precisamos de um teste sobre p.rea para determinar qual verso de rea dever ser executada. Este um exemplo de uma ocultao de implementao muito conveniente. Ela permite adicionar uma nova subclasse de polgono (por exemplo OCTGONO) sem mudar o cdigo acima de forma alguma. Note tambm a declarao var p: POLGONO. Esta uma restrio de segurana sobre o polimorfsmo da varivel p. Ela significa que p s pode apontar para objetos da classe POLGONO(ou para objetos de uma das subclasses de POLGONO). O mtodo rea que originalmente foi definido em POLGONO, sobreposto em TRINGULO. O mtodo de TRINGULO tem o mesmo nome, mas tem um algoritmo diferente. Ocasionalmente voc pode usar a tcnica da sobreposio para cancelar um mtodo definido em uma classe C por outra definio em uma das subclasses de C. Podese cancelar um mtodo, redefinido-o simplesmente para retornar um erro. Relacionado ao polimorfismo esta o conceito de sobrecarga. Sobrecarga: Ocorre quando vrios mtodos(ou operadores) definidos na mesma classe tm aquele nome ou smbolo. Dizemos que houve uma sobrecarga. Tanto o polimorfismo como a sobrecarga freqentemente requerem que o mtodo especfico a ser executado seja escolhido durante o processamento.
12
Conforme vimos no pequeno exemplo de cdigo acima, a razo que a classe exata de um objeto-alvo - e portanto, a implementao especfica do mtodo a ser executado pode no ser conhecida at o processamento. A distino entre o polimorfsmo e sobrecarga que o polimorfsmo permite que o mesmo nome de mtodo seja definido diferentemente em classes diferentes, enquanto a sobrecarga permite que o mesmo nome de mtodo seja definido diferentemente vrias vezes na mesma classe.
1.9
Genericidade
Genericidade a construo de uma classe C, de maneira que uma ou mais das classes que ela usa internamente fornecida somente durante o tempo de execuo ( durante esse tempo que um objeto da classe C instanciado). Para ilustrar o conceito de genericidade, quando pr exemplo se deseja projetar e programar uma arvore binria ordenada e balanceada mantendo listas ordenadas de clientes e produtos. Para manter estas listas ordenadas seriam necessrias duas cpias, de cdigos quase idnticos. Essa duplicao de cdigo aumenta muito a manuteno e o tempo para revises/ alteraes. Para solucionar este problema necessrio escrever a estrutura bsica do algoritmo da arvore uma s vez e ento conseguir aplica-la tantas vezes quantas quisssemos a inteiros , clientes, produtos ou qualquer outra coisa. ai que a genericidade se aplica, defini-se uma arvore-balanceada genrica , isso significa que pelo menos uma das classes usada dentro de arvore-balanceada no precisar ser atribuda at o tempo de execuo . Essa seria presumivelmente a classe dos itens a serem armazenados nos ns do objetos arvore balanceada particular que vamos instanciar. Poderamos , portanto, escrever a classe arvore-balanceada como: class arvore-balanceada [ item-classe-de-n]; var n-corrente: item-classe-n:= item-classe-n.new; ... n_corrente.print; Note que o argumento item_classe_n uma argumento cujo valor real ser fornecido somente durante o tempo de execuo. Depois pode-se fazer com que a arvore-cliente aponte para uma instancia da arvore balanceada que mantm em seus nos instancias da classe cliente, como se tivssemos duplicado o cdigo duas vezes, uma para cliente e outra para produto. O exemplo acima um exemplo de classe contigente. Uma classe contigente serve para manter objetos em alguma estrutura, geralmente complexa. A genericidade geralmente usada em orientao a objetos para projetar essa classes contigentes. Embora a genericidade no seja estritamente necessria para se escrever um cdigo reutilizvel para classes contigentes, ela certamente superior ao cdigo duplicado ou a um projeto
13
frgil em que classes arbitrarias esto misturadas dentro de uma mesma estrutura de classe contigente.
14
15

Apost PLP Aluno

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apost PLP Aluno

Enviado por

Direitos autorais:

Formatos disponíveis

Teoria de Linguagens

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

1 Linguagens de Programao : Introduo e Histrico

Linguagem FORTRAN Algol60 COBOL APL LISP SNOBOL PASCAL

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Evoluo dos Conceitos em Linguagens

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

verificar se uma seqncia de smbolos vlida. Gerando sentena vlida:

Produo Aplicada 1 3 4 6 9 12 8 15 24 2 4 7 8 11 8 15 cadeia final

Criado por Marcelo Fernandes dos Santos

<dgito> <semsinal> <nmero> <valor> | | | <expresso>

<dgito> <semsinal> <nmero> <valor> | | <expresso>

<dgito> | <semsinal> <nmero> <valor> <expresso>

Reduo de uma cadeia invlida (6 * =):

6 <dgito> <semsinal> <nmero> <valor> ?

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Fases Principais da Compilao:

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

A escolha de uma linguagem de programao deve basear-se em 7 critrios bsicos:

portabilidade sintaxe semntica

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Organizao de Dados Tipos de dados

Tipos Agregados de Dados

var a: array[1..5] of real; (pascal) float a[5];

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Criado por Marcelo Fernandes dos Santos

Estrutura de Controle a Nvel de Unidade

Criado por Marcelo Fernandes dos Santos

Introduo ao Paradigma Funcional

Criado por Marcelo Fernandes dos Santos

Linguagens de Programao Funcional (P.F.)

Criado por Marcelo Fernandes dos Santos

; se m= n; se m=1 n+n; se m=2 n+n+n; se m=3

Criado por Marcelo Fernandes dos Santos

Conceito de Programao Funcional

49 ( * ) outro caminho: Square ( 3 + 4 ) ( 3 + 4 ) * ( 3 + 4 ) (square) 7 *(3+4)(+) 7 * 7 (+) 49 (*)

7 Introduo Linguagem Scheme

Lisp ( defconst x E ) ( defun f ( x ) E )

( define ( f x1 ... xN ) E ) ( let ( ( x 1 E1 ) ( ( x 2 E2 ) ( ( xN EN ) ) E )

( defun f ( x1 ... xN ) E ) ( let ( ( x1 E1 ) ( x 2 E2 ) ( x N EN ) ) E ) Labels ( ( f1 ( p1 ) E1 ) ( fN ( pN ) EN ) ) E)

Lisp (fE) ( f E1 E2 E3 ... EN ) ( apply F E ) # ( lambda ( x ) E ) # ( lambda ( x1 x2 ... xN ) E )

Lisp t , Nil ( not E ) ( and E1 E2 ) ( or E1 E2 ) ( eq E1 E2 ) ( not ( eq E1 E2 ) ) ( if B T F) ( cond ( B1 T1 ) ( B2 T2 ) (T F))

Lisp ( + E1 E2 ... EN ) ( * E1 E2 ... EN ) ( truncate ( E1 E2 ) ) ( expt E1 E2 ) < , <= , = , >= , > ( / = E 1 E2 )

49 ( * ) outro caminho: Square ( 3 + 4 ) ( 3 + 4 ) * ( 3 + 4 ) (square) 7 (3+4)(+) 7 7 (+) 49 (*)