Apost_PLP_Aluno

5/17/2018 Apost_PLP_Aluno - slidepdf.com

http://slidepdf.com/reader/full/apostplpaluno 1/88

Teoria de Linguagens

1 LINGUAGENS DE PROGRAMAÇÃO : INTRODUÇÃO E HISTÓRICO ................. .... .5

1.1 DEFINIÇÃO..................................................................................................................................51.2 PORQUE ESTUDAR LP ?................................................................................................................51.3 HISTÓRICO..................................................................................................................................51.3.1 FORTRAN (FOR MULA TRANSLATION)..................................................................................61.3.2 COBOL (COMMON BUSINESS ORIENTED LANGUAGE)..................................................................71.3.3 ALGOL 60 (ALGORITHMIC ORIENTED LANGUAGE)....................................................................71.3.4 LISP (LIST PROCESSING)..........................................................................................................71.3.5 APL (A PROGRAMMING LANGUAGE)...........................................................................................81.3.6 BASIC (BEGINNERS ALL-PURPOSE SYMBOLIC I NSTRUCTION CODE)...............................................8

1.3.7 PL/I (PROGRAMMING LANGUAGE I).............................................................................................91.3.8 SIMULA 67...........................................................................................................................91.3.9 ALGOL 68.............................................................................................................................91.3.10 PASCAL............................................................................................................................101.3.11 PROLOG (PROGRAMMING IN LOGIC).................................................................................101.3.12 SMALL TALK..................................................................................................................101.3.13 C........................................................................................................................................101.3.14 MÓDULA 2.......................................................................................................................111.3.15 ADA..................................................................................................................................111.4 EVOLUÇÃO DOS CONCEITOS EM LINGUAGENS................................................................................11

2 CARACTERISTICAS GERAIS DE UMA LINGUAGENS DE PROGRAMAÇÃO .......15

2.1 ESPECIFICAÇÃO DE UMA LP........................................................................................................152.1.3 SINTAXE DE UMA LP................................................................................................................162.1.4 SEMÂNTICA DE LP...................................................................................................................192.2 TRADUÇÃO DE UMA LP..............................................................................................................192.2.3 I NTERPRETAÇÃO.......................................................................................................................192.2.4 COMPILAÇÃO...........................................................................................................................192.3 CARACTERÍSTICAS DE DESIGN DE LP...........................................................................................212.4 ESCOLHA DE UMA LP.................................................................................................................22

3 PARADIGMAS DE LP .........................................................................................................23

3.1 PARADIGMA IMPERATIVO DE LP..................................................................................................233.1.1 BINDING.................................................................................................................................233.1.1.1 "I NFORMATION BINDING" ......................................................................................................233.1.1.2 ESCOPO DE BINDING E U NIDADES DE EXECUÇÃO.......................................................................253.1.1.3 ESCOPO DE BINDING DE NOME...............................................................................................263.1.1.4 ESCOPO DE BINDING DE LOCAÇÃO..........................................................................................283.1.1.5 EXERCÍCIOS .........................................................................................................................303.2 PARADIGMA DECLARATIVO..........................................................................................................303.2.3 PROGRAMAÇÃO LÓGICA............................................................................................................303.2.4 O PARADIGMA FUNCIONAL DE LP............................................................................................31

3.2.4.1 PARADIGMA FUNCIONAL........................................................................................................31

Criado por Marcelo Fernandes dos Santos 1




1.3. O PARADIGMA ORIENTADO A OBJETO (OO) DE LP....................................................................32

4 ORGANIZAÇÃO DE DADOS .............................................................................................34

4.1 TIPOS DE DADOS.........................................................................................................................344.2 TIPOS EMBUTIDOS DE DADOS......................................................................................................344.3 TIPOS AGREGADOS DE DADOS.....................................................................................................344.3.1 PRODUTO CARTESIANO.............................................................................................................344.3.2 MAPEAMENTO FINITO...............................................................................................................344.3.3 SEQÜÊNCIAS............................................................................................................................354.3.4 R ECURSÃO..............................................................................................................................354.3.5 U NIÃO DISCRIMINADA..............................................................................................................354.4 TIPOS DEFINIDOS PELO USUÁRIO................................................................................................354.5 CONVERSÃO DE TIPOS................................................................................................................36

4.6 ÁREAS PROBLEMÁTICAS..............................................................................................................364.6.1 TIPAGEM FORTE......................................................................................................................364.6.2 COMPATIBILIDADE DE TIPOS......................................................................................................374.6.3 PONTEIROS..............................................................................................................................37

5 ESTRUTURAS DE CONTROLE ........................................................................................37

5.1 NÍVEL DE COMANDO..................................................................................................................375.1.1 CONTROLE SEQÜENCIAL............................................................................................................375.1.2 CONTROLE DE SELEÇÃO............................................................................................................385.1.3 CONTROLE DE R EPETIÇÃO.........................................................................................................38

5.1.4 ESTRUTURAS DE CONTROLE DEFINIDAS PELO PROGRAMADOR .........................................................385.2 ESTRUTURA DE CONTROLE A NÍVEL DE UNIDADE..........................................................................395.2.3 U NIDADES SUBORDINADAS CHAMADAS EXPLICITAMENTE...............................................................395.2.3.1 DADOS COMO PARÂMETROS...................................................................................................395.2.3.2 SUB-PROGRAMAS COMO PARÂMETROS.....................................................................................40

6 INTRODUÇÃO AO PARADIGMA FUNCIONAL ...........................................................40

6.1 HISTÓRIA DA PROGRAMAÇÃO FUNCIONAL.....................................................................................406.2 – LINGUAGENS DE PROGRAMAÇÃO FUNCIONAL (P.F.)...................................................................416.3 – DEFINIÇÃO DE FUNÇÃO............................................................................................................43

6.4 CONCEITO DE PROGRAMAÇÃO FUNCIONAL...................................................................................446.5 R EDUÇÃO DE EXPRESSÃO............................................................................................................44

7 INTRODUÇÃO À LINGUAGEM SCHEME .....................................................................45

7.1 – SOBRE A LINGUAGEM...............................................................................................................457.2 SINTAXE DA LINGUAGEM.............................................................................................................457.3 NÚMEROS..................................................................................................................................467.4 STRING.....................................................................................................................................477.5 SEQÜÊNCIAS...............................................................................................................................477.6 FUNÇÕES FINITAS.......................................................................................................................47

7.7 FORMAS FUNCIONAIS..................................................................................................................47





8 DESENVOLVIMENTO DE FUNÇÕES BÁSICAS EM SCHEME ..................................48

8.1 CONSTANTES E FUNÇÕES SIMPLES:................................................................................................48

8.2 ALGORITMOS R ECURSIVOS..........................................................................................................498.3 – MANIPULAÇÃO DE LISTAS EM SCHEME.......................................................................................508.4 – USANDO A NOTAÇÃO LAMBDA..................................................................................................51EXERCÍCIOS....................................................................................................................................51R ECURSIVO ...................................................................................................................................53

9 INTRODUÇÃO À PROGRAMAÇÃO ORIENTADA A OBJETOS ................................54

9.1 CONCEITOS BÁSICOS..................................................................................................................559.2 CARACTERÍSTICAS IMPORTANTES DE P.O.O.................................................................................55

10 INTRODUÇÃO À LINGUAGEM SMALLTALK ..........................................................58

10.1 OBJETOS EM SMT..................................................................................................................589.1.1 O QUE É UM OBJETO EM SMT...................................................................................................5810.1.3 E NCAPSULAMENTO I NFORMAÇÕES.............................................................................................5910.1.4 OBJETOS LITERAIS.................................................................................................................6010.2 MENSAGENS............................................................................................................................609.2.1 MENSAGENS U NÁRIAS..............................................................................................................6110.2.3 MENSAGENS K EYWORD..........................................................................................................6110.2.4 MENSAGENS BINÁRIAS...........................................................................................................6110.2.5 OUTROS TIPOS DE MENSAGENS................................................................................................6110.2.5.1 MENSAGENS ARITMÉTICAS...................................................................................................6110.2.5.2 MENSAGENS DENTRO DE MENSAGENS...................................................................................6210.2.5.3 MENSAGENS EM CASCATA....................................................................................................6210.2.6 VARIÁVEIS TEMPORÁRIAS........................................................................................................6310.2.7 SINTAXE DAS PRINCIPAIS MENSAGENS........................................................................................6310.2.8 ITERADORES..........................................................................................................................6410.3 IMPLEMENTAÇÃO DE CLASSES E MÉTODOS.................................................................................669.3.1 CLASSES.................................................................................................................................6610.3.3 MÉTODOS.............................................................................................................................6710.3.4 CLASS HERARCHY BRAUSER ...................................................................................................67CLASS HIERACHY BROWSER ............................................................................................................68

10.3.5 A VARIÁVEL ESPECIAL “ SELF ”................................................................................................6810.3.6 CRIAÇÃO DE NOVOS OBJETOS E O OBJETO ESPECIAL “ NIL”.............................................................6810.3.7 VARIÁVEIS DE I NSTÂNCIA........................................................................................................6910.3.8 R ECURSÃO............................................................................................................................6910.3.9 CRIAÇÃO DE CLASSES COMPLETAS.............................................................................................7010.4 DESCRIÇÃO DA CLASSE COLLECTION.........................................................................................70

11 PROBLEMA PROPOSTO .................................................................................................72

“MÉTODOS DE I NSTÂNCIA DE BRICK ”.................................................................................................72“ MÉTODOS DE CLASSES DE MOVIGCOMP”.........................................................................................72

“ MÉTODOS I NSTÂNCIA DA CLASSES MOVIGCOMP”.............................................................................72





1 PROGRAMAÇÃO ORIENTADO A OBJETO ....................................................................1

1.1 ENCAPSULAMENTO........................................................................................................................2

1.2 OCULTAMENTO DE INFORMAÇÃO E DE IMPLEMENTAÇÃO...................................................................21.3 R ETENÇÃO DE ESTADO.................................................................................................................31.4 IDENTIDADE DE OBJETO................................................................................................................31.5 MENSAGENS................................................................................................................................51.5.1 ESTRUTURA DE UMA MENSAGEM .................................................................................................51.5.3 ARGUMENTOS DE UMA MENSAGEM...............................................................................................51.5.4 OS PAPÉIS DOS OBJETOS NAS MENSAGENS....................................................................................71.5.5 TIPOS DE MENSAGEM.................................................................................................................71.6 CLASSES......................................................................................................................................81.7 HERANÇA....................................................................................................................................91.8 POLIMORFISMO..........................................................................................................................101.9 GENERICIDADE...........................................................................................................................13





1 Linguagens de Programação : Introdução e Histórico

1.1 Definição

Uma LP (Linguagem de Programação) é uma linguagem destinada a ser usada por uma pessoa para expressar um processo através do qual umcomputador pode resolver um problema. Os quatro modelos de LPcorrespondem aos pontos de vista dos quatro componentes citados. Aeficiência na construção e execução de programas depende da combinaçãodos quatro pontos de vista.

1.2 Porque estudar LP ?

1. Maior habilidade em resolver problemas: uma maior compreensão de umaLP pode aumentar nossa habilidade em pensar em como atacar osproblemas. Tanto melhor se dominarmos os vários modelos de LP.

2. Melhor uso de uma LP: compreensão das funções e implementação dasestruturas de uma LP nos levam a usar a LP de modo a extrair o máximo desua funcionalidade e eficiência.

3. Melhor escolha de uma LP: adequação ao problema.

4. Maior facilidade em aprender novas LPs: conceitos chaves comuns às LPs.

5. Melhor designer de LPs: linguagens de interfaces de sistemas, extensão deLP via operadores e tipos de dados.

1.3 Histórico

Genealogia das Linguagens de ProgramaçãoLinguagem Ano Originador Linguagens

Predecessora

s

Finalidade Pretendida

FORTRAN 1952-57 J. Backus(IBM)

------- Computação numérica.

Algol60 1958-60 Comitê FORTRAN Computação numérica.COBOL 1959-60 Comitê ------- Proc. dados comercial. APL 1956-60 K. Iverson

(Harvard)------- Proc. de Vetores.

LISP 1956-62 J. McCarthy(MIT)

------- ComputaçãoSimbólica.

SNOBOL 1962-66 R. Griswold(Bell Labs)

------- Proc. de seqüências.

PASCAL 1971 N. Wirth Algol60 Propósito geral de





(ETH Zurich) ensino e suportar programação .

C 1974 D. Ritchie

(Bell Labs)

Algol68

BCPL

Programação de

Sistemas.Modula 1977 N. Wirth

(ETH Zurich)Pascal Programação de

sistemas em temporeal.

Ada 1979 J. Ichbah et al.

(CII HoneywellBull)

PascalSimula67

Aplicações decomponentes em

tempo real.

O processo de desenvolvimento de programas originalmente consistiasó em fase de codificação. No início da computação, o computador erautilizado principalmente em aplicações científicas, cada aplicação sendoprogramada por uma pessoa. Uma linguagem de programação precisavasuportar apenas um programador trabalhando. O que, seria pelos padrõesatuais, uma aplicação extremamente simples.

O desejo de usar o computador em cada vez mais aplicações levou asua utilização em ambientes mais sofisticados e menos bem compreendidos.Isto, por sua vez, levou a necessidade de “equipes” de programadores e deabordagens 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 manutenção se tornou uma questãoimportante.

A confiabilidade de sistema se tornou muito importante devido a doisfatores: primeiro, por que os usuários estão cada vez com menos experiência.O Segundo fator é que sistemas computacionais estão sendo aplicados emáreas de risco, onde não podem haver erros .

As deficiências de linguagens de programação tem levado a grandesesforços em projetos de linguagens a fim de alcançarem objetivos ideais.

1.3.1 FORTRAN (FORmula TRANslation)

A linguagem Fortran, desenvolvida em 1956 por John Backus, foiproposta visando a resolução de problemas científicos, para isto utilizando anotação algébrica. Foi desenvolvida, inicialmente para uma máquinaespecífica, o IBM 704. É, ainda hoje, uma linguagem muito utilizada no meiotécnico-científico, tendo sido aprimorada ao longo do tempo, constituindo asdiversas versões disponíveis. Um dos motivos pelos quais o FORTRAN é aindamuito utilizado é a disponibilidade de uma vasta biblioteca de softwarecontendo rotinas freqüentemente utilizadas, tais como rotinas para cálculo defunções trigonométricas, equações algébricas polinomiais, etc, o que permiteuma redução dos custos e tempo de desenvolvimento dos programas.

Contribuições para futuras linguagens:





• variáveis• comando de atribuição• 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 deDefesa dos EUA e fabricantes de computadores , é padrão para as aplicaçõescomerciais e muito utilizada ainda hoje. Seu desenvolvimento se deu de formaindependente da máquina. O código é "English-like" e é excelente para amanipulação de arquivos.

Contribuições de COBOL para futuras linguagens:• código mais legível• estrutura de dados heterogênea (record)

1.3.3 ALGOL 60 (ALGorithmic Oriented Language)

Linguagem algébrica de origem européia, desenvolvida pelo comitêInternacional popular, destinada à resolução de problemas científicos.Influenciou o projeto de quase todas as linguagens projetadas a partir de 1960.Descrita em BNF (Backus-Naur Form), foi projetada independente daimplementação, o que permite uma maior criatividade, porém deimplementação mais difícil. É pouco usada em aplicações comerciais devido àausência de facilidades de E/S na descrição e pelo pouco interesse devendedores. Além disso, tornou-se padrão para a publicação de algoritmos.

Contribuições de ALGOL 60 para futuras linguagens:

• estrutura de blocos: habilidade de se criar blocos de comandospara o escopo de variáveis e extensão de influência de comandosde controle

• comandos de controle estruturados: if-then-else e uso de uma

condição geral para controle de iteração• recursividade: habilidade de um procedimento chamar a si próprio

1.3.4 LISP (LISt Processing)

Linguagem funcional criada em 1960, por John McCartly do grupo de IAdo MIT, para dar suporte à pesquisa em Inteligência Artificial. Foi inicialmentedesenvolvida para o IBM 704. Existem muitos dialetos pois LISP nunca foipadronizada. Porém, em 1981 surgiu o Common LISP que é um padrãoinformal. Os programas em LISP são listas.





Contribuição de LISP para futuras linguagens:

• é pioneira na idéia de computação simbólica ou não-

numérica

1.3.5 APL (A Programming Language)

Foi desenvolvida por volta de 1960 por Kenneth Iverson - Harvard, IBM.Utiliza notação matemática, com operadores poderosos, possuindo muitosoperadores e muitos caracteres o que gera grande dificuldade deimplementação. Tem uma notação compacta e é utilizada em aplicaçõesmatemáticas. Segue o modelo funcional e tem como principal estrutura dedados 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 JohnKemeny e Thomas Kurtz no Dartmouth College, teve como objetivo ensinar alunos de graduação a usarem um ambiente interativo de programação,através de uma LP de fácil aprendizado. Com o surgimento dosmicrocomputadores de baixo custo, no início dos anos 70, o BASIC tornou-semuito popular, embora não tenha contribuído muito tecnologicamente.

Contribuições de Basic para futuras linguagens:

• uma das primeiras LPs a prover um ambiente de programaçãointerativo como parte da linguagem

• execução interpretativa de programas

Exemplo de programa Basic

Organização de um programa BASIC: Um programa é constituído deuma seqüência de declarações (instruções) que devem aparecer na ordem emque deverão ser executadas, a menos que seja indicado um desvio. A seguir são apresentadas regras que se aplicam a todas as declarações em BASIC:

1. Cada declaração deve aparecer em uma linha separada.2. Uma declaração não pode possuir comprimento superior a um linha(em geral 80 caracteres).

3. Cada declaração deve ser iniciada com uma quantidade positivainteira, conhecida como número da declaração (número da linha). Duasdeclarações não podem possuir o mesmo número de identificação.

4. Declarações sucessivas devem possuir números de declaraçõescrescentes.

5. Os números das declarações devem ser seguidos de uma palavra-chave do BASIC, que indicará o tipo de instrução a ser executado.

6. Espaços em branco podem ser inseridos, sempre que se desejar,

para melhorar a leitura da declaração.





Obs: Cada linha em branco devem possuir um único número dedeclaração seguido de um espaço em branco.

1.3.7 PL/I (Programming Language I)

Desenvolvida em meados dos anos 60 pela IBM com o objetivo deincorporar características das LPs existentes numa única LP de propósito geral. Assim PL/I inclui:

• estrutura de bloco, de controle e recursividade do ALGOL 60;• subprogramas e E/S formatadas do FORTRAN;• manipulação de arquivos e registros do COBOL;• alocação dinâmica de memória e estruturas encadeadas do LISP;• operações de arrays do APL.

É uma linguagem difícil de aprender e implementar devido a sua grandecomplexidade. Além disso, faz uso de defaults.

Contribuições de PL/I para futuras linguagens:

• tratamento de interrupção - execução de procedimentosespecíficos quando uma condição excepcional ocorre

• multitarefa - especificação de tarefas que podem ser executadasconcorrentemente

1.3.8 SIMULA 67

Linguagem baseada em Algol 60, criada no início dos anos 60 por OleJohan Dahl e Kristan Nygaard, na Noruega. É destinada à descrição desistemas e programação de simulações.

Contribuição de SIMULA 67 para futuras linguagens:

• conceito de classe: Uma classe é um encapsulamento de dados eprocedimentos que podem ser instanciados em um conjunto de objetos. É oconceito predecessor ao tipo abstrato de dados (ADA e Módula 2) e dasclasses das linguagens orientadas a objeto (Smalltalk e C++)

1.3.9 ALGOL 68

É muito diferente do Algol 60. Linguagem de propósito geral que foiprojetada para a comunicação de algoritmos, para sua execução eficiente emvários computadores e para ajudar seu ensino a estudantes. Porém é de difícildescrição, o que resultou em uma baixa popularidade.

Contribuição de ALGOL 68 para futuras linguagens:

• ortogonalidade: uma LP que é ortogonal tem um

número de construtores básicos 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 fácilaprendizado e implementação, suporta programação estruturada e é adequadapara o ensino de programação. Em meados dos anos 80 também passou a ser usada para a programação em micro-computadores. Influenciou praticamentetodas as linguagens mais recentes.

Contribuições de Pascal para futuras linguagens:

• estruturas de controle flexíveis• tipos definidos pelo usuário

• arquivos• records• conjuntos

1.3.11 PROLOG (PROgramming in LOGic)

Linguagem desenvolvida em 1972 em Marseille na França. É destinadaa aplicações de Inteligência Artificial e se baseia em lógica formal. É a LP doprojeto japonês de quinta geração.

1.3.12 SMALL TALKCriada por Alan Kay da Xerox - Palo Alto no início dos anos 70.

Apresenta um ambiente de programação com menus pop-up, windows emouse (modelo para Apple Macintosh). Segue o modelo orientado a objetos,possuindo o conceito de classe do SIMULA 67 mais encapsulamento, herançae instanciação.

Contribuições de SmallTalk para futuras linguagens:

• primeira LP a utilizar o paradigma de programação interativa• introduz o conceito de LP extensível

1.3.13 C

Desenvolvida pelo Bell Lab no início dos anos 70, visando aimplementação do UNIX. Possui um padrão feito por Kernighan e Ritchie em1978. Tem facilidades para a programação em "baixo nível" e gera códigoeficiente. Possui um grande conjunto de operadores, o que permite um códigocompacto, porém de baixa legibilidade. É excelente para construir programasportáveis.





1.3.14 MÓDULA 2

Criada por Niklaus Wirth no final dos anos 70, é uma linguagem de

propósito geral, baseada em melhorias no Pascal. É boa para projetos dedesenvolvimento de software de grande porte. Além disso foi usada paraensinar programação. Módula 2 elaborou Pascal em:

• módulos podem ser usados para implementar TAD (Tipos Abstratosde Dados)

• todas as estruturas de controle têm uma palavra-chave determinação

• co-rotinas - execução intercalada• tipos de procedimentos

1.3.15 ADA

Foi desenvolvida no início dos anos 70 pelo Departamento de Defesados Estados Unidos. É dedicada aos "embedded systems" (operam como partede um sistema maior) e se baseia no Pascal. Teve um padrão em 1983. Alémdisso, usa conceitos de classe do Simula 67, adota o tratamento de exceçõesde PL/I e provê facilidades para processamento concorrente. Foi projetada paraapoiar aplicações numéricas, programação de sistemas e aplicações queenvolvem considerações de tempo real e concorrência. Seu nome se deve a ADA Augusta, 1a programadora, colaboradora de Charles Babbage - século19.

1.4 Evolução dos Conceitos em Linguagens

Linguagens de programação podem favorecer a adoção demetodologias de projetos sistemáticos de programas, por outro lado, alinguagem tem forte influencia na confiabilidade, legibilidade e modificabilidadedos programas. Regras e metodologias que são úteis no desenvolvimento desistemas (programas) confiáveis e de alta qualidade podem ser, e estão sendocada vez mais, incorporados nas linguagens de programação a fim de

encorajar os usuários a aplicarem estas metodologias ou, pelo menos, parafacilitar sua aplicação.

O propósito desta seção é apresentar as idéias importantes que têminfluenciado a evolução dos projetos de linguagens, tais como:

- Conceito de abstração De dados De controle

- Conceito de correção de programas- Influência da linguagem na programação de grande porte.

a) O Papel da Abstração





Computadores estão substituindo pessoas em muitas aplicações, desdeadministrativas até controle de processos. Para substituir o procedimentomanual, 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 “abstração” darealidade. Abstração é o processo de identificar as qualidades ou propriedadesimportantes de fenômeno a ser modelado. Usando o modelo abstrato, pode-seconcentrar unicamente nas qualidades ou propriedades relevantes e ignorar asirrelevantes. O que é relevante depende da finalidade para a qual a abstraçãoestá sendo projetada.

Sub-programas e macros também foram introduzidos pelas linguagens demontagem como um meio de o programador nomear uma atividade descritapor um grupo de ações, e considerá-las como uma única ação

Sub-programas são ferramentas úteis para a programação metódica,pois são mecanismos para construir abstrações. Um sub-programa éimplementação de uma abstração, enquanto uma chamada do sub-programarepresenta o uso da abstração.

Abstrações de dados modelam os dados manipulados pelos programascombinando ações elementares em formas de complexidade arbitrária.

a.i ) Abstrações de Dados

a.i.i ) Nas Primeiras Linguagens

Linguagens a nível de máquina encaram os dados armazenados comoseqüências de “bits” que podem ser manipulados pelas instruções de máquina.

Os primeiros passos rumo as abstrações de dados foram dados pelaslinguagens FORTRAN, COBOL e Algol60. Nestas linguagens as informaçõessão armazenadas em posições de memória (inteiros, reais, lógicos, ...) e nãocomo “bits” anônimos. A decisão sobre quais abstrações de dados incluir emuma linguagem de programação foi ditada principalmente pelas máquinas paraas quais a linguagem era destinada e pelo espectro de aplicações quepretendia-se que a linguagem cobrisse.

Como resultado, nenhuma linguagem acaba sendo apropriada para

todas as aplicações, já que o programador fica limitado pelo poder expressivodo conjunto fixo de abstrações fornecida pela linguagem. a.i.ii ) Nas Linguagens Modernas

O caminho seguido pelas linguagens de geração mais modernas é, emcerto sentido menos ambicioso, mas tem mostrado ser mais efetivo. Elastentam atingir generalidade, não fornecendo um conjunto exaustivo deabstrações embutidas, mas sim provendo mecanismos flexíveis e fáceis deusar, pelos quais, o programador pode definir novas abstrações.

As abstrações identificadas para o projeto do sistema ficam refletidas,

pelo menos em algum grau, pela estrutura resultante do programa. Como





conseqüência, os programas ficam mais fáceis de serem entendidos emodificados e têm maior probabilidade de estarem corretos.

Em um aspecto importante, contudo, abstrações embutidas e definidas

pelo usuário se diferenciam. Embutidas escondem do programador arepresentação subjacente, a qual não pode ser manipulada diretamente.Enquanto que as definidas pelos usuários, podem ser manipuladas.

Existem também as linguagens que provêem que os usuários definamtipos abstratos de dados, que devem satisfazer as seguintes condições.

(a) – A associação de uma representação às operações concretas emuma unidade apropriada da linguagem, a qual, implementa os novostipos; (protótipos e nomeclatura)

(b) – Esconder a representação do novo tipo das unidades que usameste tipo. (encapsulamento)

Onde (a) faz com que as versão final do programa reflita as abstraçõesencontradas durante o projeto do programa. A estrutura resultante do programafica auto-explicativa. A propriedade (b) facilita a modificabilidade do programa.

O conceito tipo abstrato de dados vem do princípio de esconder informação. Tipos abstratos de dados escondem detalhes de representação edirecionam o acesso aos objetos abstratos por meio de procedimentos. Arepresentação está protegida contra manipulação direta. A modificação daimplementação de um tipo abstrato não afeta o resto do programa.

a.ii ) Abstração de Controle

Estruturas de controle descrevem a ordem em que instruções ou gruposde instruções devem ser executadas. Como nas abstrações de dados,abstrações de controle podem determinar áreas de aplicação. As estruturas decontrole podem ser classificadas em:

(a) – A nível de instrução: Aquelas que são usadas para ordenar a ativação deinstruções individuais.

(b) – A nível de unidade: Aquelas que são empregadas para ordenar a

ativação de unidades de programa.

a.ii.i ) A nível de instrução as máquinas convencionais fornecem dois tipos decontrole: seqüencialização e desvio.

(a) – SeqüencializaçãoIncrementação automática do contador de programaapós cada instrução.

(b) – Desvio: Altera o valor do contador de programa para umaposição desejada, ao invés da próxima instrução.





a.ii.ii ) A Nível de Unidade

As linguagens de programação fornecem meios para agrupar instruções

implementando abstrações de ação em uma unidade de programa apropriada,tais como, sub-programas e blocos ( sub-programas em grau menor). Umachamada de uma sub-programa força a transferência do controle para omesmo, que após completar sua tarefa devolve o controle para a unidadechamadora.

b) Correção de Programa

Correção é um dos requisitos básicos de qualquer programa ou sistema.Existem dois métodos para se construir programas corretos, são eles:

(a) – Correção de Erros

Consiste basicamente em sanar um erro de um programa jáescrito, quando o mesmo aparece, ou seja, é descoberto;

(b) – Prevenção de Erros:Isto é, construir programas, ou tentar construir, já corretos (o queé improvável).

Uma maneira de favorecer a produção de programas corretos é tornar os esforços de projetos e codificação fáceis de enfrentar, de modo que possater confiança no comportamento desejado do sistema. Abstrações de dados econtrole são ferramentas poderosas para dominar a complexidade doprograma. Mecanismos de linguagens que permitem a produção de programasbem estruturados e corretos. Estas estruturas de programas possibilitamsubdividir a tarefa complexa de raciocinar sobre um objeto grande (o programainteiro) em pensar sobre objetos abstratos menores. Além disso, as unidadesdo programa, individualmente, devem ser fáceis de escrever e de entender, demodo que possíveis erros possam ser localizados e corrigidos comsimplicidade.

Mas, mesmo os programas que são feitos sob a máxima rigorosidadenão estão livres de erros, logo são necessárias estratégias para remover taiserros, tal como testes de consistência, que são providos pela próprialinguagem. Estes testes consistem em verificar se o programa esta

sintaticamente e semanticamente correto.Testes de consistência efetuados antes de executar o programa sãochamados de testes estáticos, e os efetuados em tempo de execução sãochamados de testes de tempo de execução (ou dinâmicos).

O método tradicional de certificar programas consiste em “testar” oprograma submetendo uma amostra de entradas, tiradas dos documentos deespecificação do programa, e observar se as saídas condizem com oesperado. Porém, esse método identifica a presença de erros, mas não aausência! Devido a esse problema um outro método é a verificação deprogramas; que almeja a correção do programa independente de suaexecução.





c) Programação de Grande Porte

A produção de grandes sistemas de programação freqüentemente

requer a coordenação das atividades de um grande número de pessoas. Osprogramas são montados como coleção de módulos individuais, possivelmenteescritos por pessoas distintas e codificados em diferentes linguagens.

A gerência bem sucedida do projeto, produção, correção e manutençãode tais sistemas de programação é uma tarefa formidável, envolvendoproblemas que se estendem desde a sociologia das relações humanas até asmetodologias para a produção de programas. Esta gerência requer metodologias e ferramentas adequadas a fim de manter a complexidade sobcontrole.

Supõe-se implicitamente que os sistemas grandes são constituídos decomponentes individuais, chamados “módulos”. A modularidade, em verdade, é

geralmente reconhecida como o único guia disponível para dominar acomplexidade do projeto e da implementação de sistemas grandes ecomplexos.

Uma noção mais útil de modularidade fica em termos deindependência. Isto significa que cada módulo deve ser compreendido, epossivelmente implementado, independentemente dos outros módulos dosistema. Cada módulo deve realizar uma única função conceitual simples dosistema; consequentemente, restrições sobre o tamanho dos módulosaparecem automaticamente como subprodutos do processo de projeto. Ocultar informações como princípio de projeto favorece a produção de módulosaltamente independentes de fato, decisões de projeto internas a um móduloficam ocultas e não afetam a correção da cooperação entre os módulos, umavez que as interfaces dos módulos tenham sido projetadas, os módulos podemser desenvolvidos independentes uns dos outros, armazenados em umabiblioteca e depois montados para construir um programa único.

As linguagens de programação devem prover mecanismos para adefinição de módulos e para ocultar informação. Devem também fornecer mecanismos para estruturar uma coleção de módulos em um sistema único.Finalmente, deve ser possível desenvolver e certificar módulos separadamente.

A combinação de uma linguagem de programação adequada com váriasferramentas poderosas, integradas, fáceis de usar e sensíveis à linguagem, isto

é, um ambiente para desenvolvimento de sistema, torna-se atualmente o fator chave em melhorar a qualidade dos programas.

2 Caracteristicas Gerais de uma Linguagens de Programação

2.1 Especificação de uma LP

A descrição de uma linguagem de programação envolve dois aspectos:sintaxe e semântica. A sintaxe é o conjunto de regras que determinam quaisconstruções são corretas e a semântica é a descrição de como as construçõessintaticamente corretas são interpretadas ou executadas.





Ex: a := b (Pascal)

• comando de atribuição correto (sintaxe)

• substitua valor de a com o valor atual de b (semântica)2.1.3 Sintaxe de uma LP

A sintaxe de uma LP é descrita por uma Gramática que tem comoelementos básicos:

1. Conjunto de Símbolos Terminais (T): aparecem nas construções daLP; um conjunto de caracteres.

2. Conjunto de Símbolos Não Terminais (NT): não presentes na LP;nomes de categorias sintáticas definidas pelas produções. Notação: < .

3. Conjunto de Produções (P): definições de símbolos não terminais.Forma: <NT ::= {T U NT}*.

4. Símbolo Inicial (S): um dos NT.

Exemplo: Gramática de uma linguagem de calcular em BNF (BackusNaur Form):

P:

<cálculo> ::= <expressão> =<expressão> ::= <valor> | <valor><operador><expressão><valor> ::= <número> | <sinal><número><número> ::= <semsinal> | <semsinal>.<semsinal><semsinal> ::= <dígito> | <dígito><semsinal><dígito>::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9<sinal> ::= + | -<operador> ::= + | - | / | *

--- T, --- NT, --- Metalinguagem

S = <cálculo>

Na notação anterior, poderíamos expressar: opcionalidade [ ], repetição {} e alternância |. O uso desses 3 metasímbolos estende a BNF para a notaçãoEBNF (Extended BNF).

Rescrevendo os NT <expressão>, <valor>, <semsinal. e <número>:

<expressão> ::= <valor> [<operador><expressão>]<valor> ::= [<sinal>] <semsinal> [.<semsinal>]<semsinal> ::= <dígito> {<dígito>}

PS: <número> pode ser eliminado.

Uma Gramática pode ser usada para gerar sentenças válidas e para





verificar se uma seqüência de símbolos é válida.

Gerando sentença válida:

Cadeia AtualProduçãoAplicada

S = <cálculo> 1

<expressão> = 3

<valo><operador><expressão> = 4

<número><operador><expressão> = 6

<semsinal><operador><expressão> = 9

<dígito><semsinal><operador><expressão> =

12

2<semsinal><operador><expressão> = 8

2<dígito><operador><expressão> = 15

25<operador><expressão> = 24

25 * <expressão> = 2

25 * <valor> = 4

25 * <número> = 7

25 * <semsinal>.<semsinal> = 8

25 * <dígito>.<semsinal> = 11

25 * 1.<semsinal> = 8

25 * 1.<dígito> = 15

25 * 1.5 = cadeia final

Verificando se 6 + 3 / 12 = é um cálculo:

6 + 3 / 1 2 =





<dígito> <operador> <dígito> <operador> <dígito> <dígito> |

<semsinal> | <semsinal> | | <semsinal> |

<número> | <número> | <semsinal> |

<valor> | <valor> | <número> |

| | | | <valor> |

| | | |<expressão>

|

| |<expressão>

|

<expressão> |

Redução de uma cadeia inválida (6 * =):

6 * =

<dígito> <operador> |

<semsinal> | |

<número> | |

<valor> | |

? ? ?

Gramáticas que podem ser descritas em BNF e EBNF são conhecidascomo Gramáticas Livres de Contexto: definições de NT são independentes docontexto em que o NT aparece.

A maioria das LPs não são Livres de Contexto - elas contém algumasregras sensíveis ao contexto. Ex: "variável deve ser declarada antes de ser usada". São, assim, chamadas linguagens sensíveis ao contexto. Os métodosformais para reconhecer linguagens sensíveis ao contexto são bastantecomplexos. Na prática, especifica-se uma LP como livre de contexto e trata-sea sensibilidade ao contexto de maneira informal.





2.1.4 Semântica de LP

A semântica de uma LP, que corresponde a como esta LP será

implementada, pode ser descrita de maneira formal, porém, em geral, édescrita de maneira informal. Esta apresentação dará um enfoque operacionalao problema, com o objetivo de fornecer uma visão dos problemas encontradosquando da implementação de linguagens.

2.2 Tradução de uma LP

Existem dois métodos para se traduzir um programa escrito em umadeterminada linguagem de programação para a linguagem de máquina:Interpretação e Compilação.

2.2.3 Interpretação

Um interpretador traduz o programa fonte um comando por vez e chama

uma rotina para executar esse comando. A vantagem é que o interpretador nãotraduz comandos que podem não ser executados e pode relatar erros nalinguagem original em cada ponto de execução. Na prática as linguagensinterpretadas servem para a realização de uma prototipagem rápida.

2.2.4 Compilação

Um Compilador traduz o programa fonte inteiro, produzindo um outroprograma equivalente, em linguagem executável. A vantagem é que ocompilador precisa traduzir um comando apenas uma única vez, nãoimportando quantas vezes ele será executado. Na prática o compilador é usadopara gerar o código definitivo (eficiente) de um programa.

O processo de compilação:





Fases Principais da Compilação:





2.3 Características de Design de LP

O principal objetivo de uma LP é auxiliar o programador no processo dedesenvolvimento de software. Isso inclui auxílio no projeto, implementação,teste, verificação e manutenção do software. Algumas características que

contribuem para isso são:• Simplicidade:

• Nível semântico: número mínimo de conceitos e estruturas.Os conceitos devem ser naturais, de fácil aprendizado, compouco risco de má interpretação.

• Nível sintático: cada conceito deve ter representação únicae "clara" - evitar sintaxe muito concisa, pois isto é contraprodutivopara inteligibilidade. Deve-se excluir múltiplas representações e

representações confusas.• Abstração: apenas aspectos relevantes dos objetos. Tem reflexo nas

tarefas de design, implementação e modificação de programas.

• Nível de dados: programador pode trabalhar maisefetivamente usando abstrações mais simples, que não incluamdetalhes irrelevantes dos dados.

• Nível de procedimentos: facilita modularidade e boaspráticas de design.





• Expressividade: facilidade com que um objeto pode ser representado. As LPs devem permitir uma representação natural de objetos eprocedimentos (por exemplo, estruturas de dados e de controle

apropriadas). Simplicidade e Expressividade são características umtanto antagônicas e a maior aplicação de uma ou outra depende dodomínio de aplicação do problema. Deste modo deve-se restringir osproblemas a domínios específicos.

• Ortogonalidade: refere-se à integração entre os conceitos, o grau deinteração entre diferentes conceitos, e como eles podem ser combinados de maneira consistente. Por exemplo, quando uma "string"não pode ser passada como parâmetro, os conceitos de "string" e"parâmetro" não podem interagir, e portanto, há falta de ortogonalidade. Além disso, se uma LP usa o operador := para atribuição de "inteiro" e <-

para atribuição de "string", então o conceito "atribuição interageinconsistentemente com os de "inteiro" e "string". A ortogonalidade reduzo número de exceções de regras e torna a LP mais fácil de ser aprendida. Também leva a dificuldades: combinações difíceis de seimplementar ou mesmo improváveis de ocorrer.

• Portabilidade: movimento de um programa de uma máquina a outra.Utilização de um padrão independente de máquina.

2.4 Escolha de uma LP

A escolha de uma linguagem de programação deve basear-se em 7 critériosbásicos:

• implementação

• disponibilidade quanto à plataforma• eficiência: velocidade de execução do programa objeto

• competência na LP

• experiência do programador • competência do grupo envolvido

• portabilidade • necessidade de rodar em diferentes máquinas

• sintaxe

• certos tipos de aplicação acomodam-se melhor em certas sintaxes

• semântica

• aplicação X facilidades• por exemplo, para processamento concorrente pode-se usar ADA, para

utilização de recursividade pode-se usar Pascal

• ambiente de programação





• ferramentas para desenvolvimento de software diminuem o esforço deprogramação

• bibliotecas

• modelo de computação

• aplicação X modelo de computação• por exemplo, para realização de busca heurística é adequado o modelo

lógico, para simulações, o modelo orientado a objeto

3 Paradigmas de LP

3.1 Paradigma Imperativo de LP

O modelo Imperativo é baseado na perspectiva do computador: aexecução seqüencial de comandos e o uso de dados são conceitos baseadosno modo como os computadores executam programas no nível de linguagemde máquina. Este modelo é o predominante. As LPs imperativas são de fáciltradução. Um programa imperativo é equivalente a uma seqüência demodificações de locações de memória.

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 ações dos computadores ao nível delinguagem de máquina (LM). Nesse nível, os computadores operam com 2unidades principais: CPU e memória. Uma unidade de execução típica em LMconsiste de 4 passos:

1 - Obter o endereço de locações para um resultado e 1 ou mais operandos2 - Obter o dado operando da(s) locação(ões) do operando

3 - Computar o dado resultado dos dados operandos4 - Armazenar o dado resultado na locação do resultado

Exemplo:

A := B + C seria executado como:

1 - Obter os endereços de A, B e C2 - Obter os dados dos endereços B e C3 - Computar o resultado de B + C4 - Armazenar o resultado na locação de A

Apesar da abstração de endereços em nomes, as LPs imperativasmantém os 4 passos como uma unidade de programa padrão. Essa unidade de





execução se tornou a unidade fundamental de LP imperativas - e é chamadade comando de atribuição (em BNF: <nome> <op_atribuição> <expressão>).

De fundamental importância para a performance dessa atribuição é oestabelecimento e uso de um número de bindings ("ligações"):

passo 1: binding entre nomes e locações de operandos e resultados

passo 2: binding entre locação e valor para estabelecer valores de operandos

passo 4: binding entre locação do resultado e o valor computado

No passo 3, a computação depende da interpretação dos dados e dosoperadores definidos. LPs relacionam dados e operadores através de tipos.

Veremos o papel de tipo em binding. Além disso será discutido o Escopo dosbindings: definição e mudança de bindings. Dados objetos & Bindings

Dado objeto = (L, N, V, T)

onde L - locação, N - nome, V - valor, T - tipo

Binding é a atribuição de valor a um dos quatro componentes acima. Essesbindings podem ser alterados em certas ocasiões.

Os bindings podem ocorrer em tempo de compilação, em tempo deloading (quando o programa LM gerado pelo compilador está sendo alocado àlocações específicas na memória), ou em tempo de execução.

Bindings de locação geralmente ocorrem em tempo de loading, mastambém podem ocorrer em tempo de execução (variáveis em procedimentos ealocação dinâmica).

Bindings de nome ocorrem tipicamente em tempo de compilação,quando uma declaração é encontrada. (em arrays e records ocorrem bindings





compostos de nomes).

Bindings de tipo ocorrem geralmente em tempo de compilação, através

de declarações de tipo. Veja exemplos dos efeitos da declaração de tipos em ADA nas figuras seguintes.

Binding de tipo dinâmico ocorre durante tempo de execução, nãohavendo declarações. O tipo do dado objeto é determinado pelo tipo do valor, eportanto, uma mudança de valor implica em novo binding.

3.1.1.2 Escopo de Binding e Unidades de Execução

Divisões de um programa:

• programa - maior divisão; unidade executável fundamental• blocos• comando - menor divisão; unidade indivisível

O objetivo de se juntar unidades de execução, neste caso, é paraidentificar o escopo de bindings.

Comandos:

• unidade de controle fundamental de LPs imperativas• menor unidade traduzível• comandos compostos (condicionais, iterativos)

Em LPs como LISP e PROLOG, os comandos possuem um únicoformato:

LISP - (nome_função (par1 ... parn) <corpo>)

PROLOG - predicado (arg1, ..., argn) :- <corpo>.

A maioria das LPs imperativas possuem várias sintaxes para tiposdiferentes de comandos.

Referência a comandos: labels

<label> : <comando>

Binding - tempo de compilação (Pascal, ADA, FORTRAN)

- tempo de execução (SNOBOL, APL)

Variações: labels podem ser:

• obrigatórios - BASIC• opcionais - Pascal, ADA, FORTRAN, C• inteiros - Pascal, FORTRAN, BASIC

• identificadores - ADA, C





• declarados explicitamente - Pascal• declarados implicitamente - ADA, FORTRAN• detectados por posição - FORTRAN

• detectados por notação - Pascal, CDelimitação de Comandos:

• um comando por linha - FORTRAN• marca delimitadora - ADA, C, Pascal (em ADA e C ';' termina

comandos e em Pascal separa comandos)

Pascal:

...x := x + 1else

... 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 funções

3 - Unidades de compilação

Blocos compilados separadamente e depois unidos paraexecução

4 - Escopo de bindings

Bloco de comandos sobre os quais bindings específicos sãoválidos

3.1.1.3 Escopo de Binding de Nome

Blocos que definem um escopo de binding de nome contém, em geral,duas partes:

1. Uma seção de DECLARAÇÕES, que define os bindings que valemdentro do bloco

2. Uma seção EXECUTÁVEL, que contém os comandos do bloco, onde





valem os bindings

Sintaticamente, isso requer delimitadores.

Ex:...BLOCK A;

DECLARE I;BEGIN A... {I de A} - binding válidoEND A;...

Num bloco, dois tipos de bindings:

local - feito por declarações no bloco

não-local - feito por declaração 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.

Política do Escopo Léxico ou Estático:

1. Se um nome tem uma declaração num bloco, este nome é ligado aoobjeto especificado na declaração.

2. Se um nome não tem declaração num bloco, ele é ligado ao mesmo





objeto ao qual ele foi ligado no bloco que contém o bloco atual, notexto do programa. Se o bloco não está contido em outro, ou se onome não foi ligado no bloco que contém este, então o nome não

está ligado a qualquer objeto no bloco atual.

"Hole-in-scope" - Situação em que um bloco redeclara um nome jáligado no ambiente que o contém. Neste caso, a declaração local se sobrepõeao binding não-local, fazendo o objeto ligado não-localmente inacessível nobloco 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 é inacessível em A}end A

... {X de P; Y de P}end P;

Escopo Estático x Escopo Dinâmico

Escopo Dinâmico: O ambiente "global" de uma unidade (procedure) é oambiente da unidade que a chamou. Isto é, uma procedure herda comoambiente global aquele da unidade que a chamou e, portanto, este só pode ser determinado em tempo de execução.

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 Locação

Hipótese assumida: binding de locação feito em tempo de loading,permanecendo válido durante toda a execução do programa.

Efeito colateral: ao re-executar um bloco, as variáveis locais reteriam osvalores da execução anterior.

Se um novo binding de locação for feito a cada nova entrada no bloco,nenhuma suposição poderia ser feita.

Exemplo:

program Pdeclare I;





begin Pfor I := 1 to 10 do

block A;

declare J;begin A

if I = 1 then {I de P; J de A}J := 1

elseJ := J * I {assume-se que J retém valor de

execução prévia}endif

end A;end P

Desvantagem: memória para todos os blocos do programa deve ter reservada por todo o tempo de execução do programa.

Alternativa: (binding dinâmico) Fazer o binding de locação, bem como ode nome, em tempo de execução, a cada entrada de um bloco, desfazendoesses bindings quando da saída do bloco. (Alocação dinâmica de memória).

Extensão do binding: período de tempo, durante execução, em que obinding é válido.

Implementação: via registros de ativação que são registros contendoinformações sobre uma unidade de execução, necessárias para restabelecer

sua execução, depois de ela ter sido suspensa. Para efeito de binding delocação, o registro de ativação precisará conter apenas as locações para todosos objetos ligados localmente, mais um ponteiro para o registro de ativação dobloco que o contém.

Funcionamento: Conforme um bloco é ativado, seu registro é colocadono topo de uma pilha. No término de sua execução, seu registro édesempilhado.

Uso da pilha para localizar objetos:

1. Procura no registro do topo pelo objeto ligado ao nome.

2. Se não encontrar, procure-o no registro apontado por ele; continuenesse processo até encontrá-lo na lista, ou a lista acabar.

Esta busca pode ser otimizada, uma vez que se sabe, em tempo decompilação, a estrutura da pilha e de cada registro de ativação.

Em C:

"source file" - outra unidade de execução

Uma declaração precedida pela palavra extern torna visível um objetodaquele nome, que tenha sido definido num source file diferente. Esses





arquivos podem ser compilados separadamente e, portanto, servem comounidades de compilação.

extern int compare_strings();extern char *read_string();

extern void copy_string();

3.1.1.5 Exercícios

1. Em quais situações bindings de locações são feitos em tempo de execução?

2. Que fatores deve-se considerar ao escolher entre um espaço deidentificadores mais ou menos restritivo?

3. Algumas LPs permitem o binding de tipo a um objeto em tempo deexecução. Discuta vantagens e desvantagens desta estratégia.

4. Quando uma LP oferece tipos reais em ponto fixo e em ponto flutuante, oque é importante considerar ao decidir o tipo de um dado objeto?

5. Que tipo de uso se faria de bindings de labels em tempo de execução? Queperigos isso oferece?

6. Considere o mecanismo de passagem de parâmetros do Pascal.

a) O binding feito entre os parâmetros atuais e os formais éestático ou dinâmico?

b) Especule como esse mecanismo funcionaria se fosse ooposto do que você respondeu acima.

3.2 Paradigma Declarativo

Uma linguagem declarativa é aquela na qual um programa especificauma relação ou função. Quando programa-se no estilo declarativo, não faz-seatribuições de variáveis do programa. Essas linguagens são de mais alto níveldo que as linguagens imperativas.

Os paradigmas declarativos são tirados da matemática: lógica, da teoriade funções e do cálculo relacional.

3.2.3 Programação Lógica

A programação lógica é baseada em um subconjunto do cálculo de

predicados, incluindo declarações escritas como clausulas de Horn. Ocalculo de predicados provê axiomas e regras, tal que um fato pode





produzir novos fatos a partir de outros fatos conhecidos. Clausulas de Hornpermitem somente um novo fato ser deduzido em uma única declaração.

Um programa baseado em lógica consiste de uma série de axiomas ou

fatos, regras de inferência e uma pergunta ou teorema a ser provado. Aresposta é verdadeira se os fatos satisfazem ao teorema e falso docontrário. PROLOG, PARLOG e PROPLOG são exemplos de linguagensdeste paradigma.

3.2.4 O Paradigma Funcional de LP

O modelo Funcional focaliza o processo de resolução do problema. Avisão funcional resulta num programa que descreve as operações que devemser efetuadas para resolver o problema.

Linguagens Funcionais: LISP

3.2.4.1 Paradigma Funcional

Função:

f: {domínio} {contra-domínio}

Programa:

p: {possíveis entradas} {possíveis saídas}

Uma função tem três componentes básicos: domínio: conjunto deobjetos aos quais a função se aplica, contra-domínio: conjunto de objetosresultantes da aplicação da função, e definição: especificação de como umobjeto do contra-domínio é determinado a partir do domínio.

Há um quarto componente opcional: o nome da função.

Exemplo 1: função double

Domínio: Z

Contra-Domíno: ZDefinição: x + x, onde x é elemento do domínio

Nome: double

Notação matemática: double(x) = x + x

double: integer integer

Note que o operador + é usado na definição, e + é uma função também.

Uma notação mais consistente seria então: +(x, y), indicando uma

função (+) com domínio o conjunto de pares de inteiros.





Expressão Lambda (Church - 1941)

Definição de função:

[<nome_função>] l <lista nomes elementos>.<definição>

Ex: double l x.x + x

Aplicação da função:

<especificador_função>:<valor_domínio> , ondeespecificador_função pode ser o nome ou a definição da função.

Ex: Aplicar a função double ao valor 2: double: 2 ou lx.x + x: 2

Exemplo 2: função max

max: integer x integer integer

max lx, y.if x y then x else y

max:<4, 2

Exemplo 3: função abs

abs lx.max:<x, -x>

abs: 6 max: <6, -6> if 6 > -6 then 6 else -6 6

Composição de funções:

Notação matemática: f(x) = abs(double(x))

Expressão Lambda: definimos essa composição por um novooperador:

f abs o double

isto é f é equivalente a sucessivas aplicações de double e abs: f: -3 abs: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 programaOO é equivalente a objetos que mandam mensagens entre si. Os objetos doprograma equivalem aos objetos da vida real (problema).

A abordagem OO é importante para resolver muitos tipos de problemasatravés de simulação.

A primeira linguagem OO foi Simula, desenvolvida em 1966 e depoisrefinada em Smalltalk. Existem algumas linguagens híbridas: Modelo

Imperativo mais características de Orientação a Objetos (OO). Ex: C++.





No modelo OO a entidade fundamental é o objeto. Objetos trocammensagens entre si e os problemas são resolvidos por objetos enviandomensagens uns para os outros.

Linguagens Orientadas a Objeto: SMALL TALK





4 Organização de Dados

4.1 Tipos de dados

De modo geral programas são feitos para produzir dados (resultados), apartir de outros dados de entrada. Desta forma, as linguagens provêemconjuntos de dados pré-determinados e também formas para usuáriosdefinirem seus próprios tipos de dados. Alguns desses tipos de dados serãodescritos em seguida.

4.2 Tipos Embutidos de Dados

Este tipo é provido pela própria linguagem, como tipos primitivos.Exemplos: Inteiros, Reais, Lógicos,...Estes seguem quatro propriedades úteis:

1 – Invisibilidade da representação;2 – Uso correto de variáveis pode ser testado em tempo de tradução;3 – Desambiguação de operadores pode ser feita em tempo de

tradução;4- Controle de precisão.

4.3 Tipos Agregados de Dados

As linguagens de programação permitem que o programador especifiqueagregações 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

A1x A2 x...x An, é um conjunto cujos elementos são n-túplas ordenadas (a1, a2 , ...,an) onde ai ∈ Ai .

Exemplos: records (COBOL, Pascal);structures (C, Algol68).

4.3.2 Mapeamento Finito

Um mapeamento finito é uma função de um conjunto finito de valores deum tipo do domínio DT em valores de um tipo do co-domínio C T . As linguagensde programação possuem um mecanismo de array que permite a definição demapeamento finito.





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

Onde existem três tipos de escolhas possíveis:1- Amarração em tempo de compilação;2- Amarração em tempo de criação do objeto;3- Amarração em tempo de manipulação do objeto.

4.3.3 Seqüências

Uma seqüência consiste em um número arbitrário de ocorrências deitens de dados e de um determinado tipo de componente C T . Este mecanismode estruturação tem a propriedade, importante, de deixar em aberto o númerode ocorrências do componente e, portanto, requer que a implementação sejacapaz de armazenar objetos de tamanho arbitrário.

Exemplo: Strings, Arquivos,....

4.3.4 Recursão

Um tipo de dados recursivo T pode Ter componentes que pertençam ao

próprio tipo T . Para definir-se um tipo recursivo de dados pode-se usar o nomedo próprio tipo na sua definição.

Exemplo: Listas de ponteiros, árvores, ...

4.3.5 União Discriminada

A união discriminada é um mecanismo de estruturação que especificaque uma escolha será feira dentre diferentes estruturas alternativas. Cadaestrutura alternativa é chamada de uma variante.

Exemplo: Var a: record case tag of 1: b: string; (Pascal);2: b:integer;

end;

union (C).

4.4 Tipos Definidos Pelo Usuário





As linguagens permitem que o programador defina objetos deinformação complexos como agregados de itens elementares. Essaslinguagens permitem também que os programadores renomee tipos existentes

ou nomee novos tipos agregados definidos.

Exemplos: typedef byte char;byte nome[10]; (C);

type complexo = record partreal:real; (Pascal). parteim:real;

end; Isso favorece a legibilidade, modificabilidade, fatoração e testes de

consistência.

4.5 Conversão de Tipos

Freqüentemente é necessário converter um valor de um tipo em umvalor de outro tipo, por exemplo quando queremos somar uma variável comuma variável real. Na maioria das linguagens essa conversão é implícita(baseada em uma hierarquia de tipos da linguagem), que pode levar a erros.Uma outra maneira, é fazer uma conversão por referência, forçando aconversão.

Exemplos:float r,q;int i;

q = i/r; /* há uma conversão implícita de i parafloat, chamada de alargamento */

r = (float)i; /* há uma conversão forçada de i parafloat usando um molde (chamada dereferenciação ou casting) */

4.6 Áreas Problemáticas

4.6.1 Tipagem Forte

Um importante efeito da introdução de tipos é a possibilidade de testesestáticos de tipos. Os programas resultantes tem maior chance de estaremcorretos, e também de serem mais eficientes, porque não é necessário ter descritores em tempo de execução nem efetuar testes sobre eles. Umalinguagem é dita fortemente tipada se permite que todos os testes de tipossejam efetuados estaticamente.





4.6.2 Compatibilidade de Tipos

Regras de compatibilidade (ou equivalência) de tipos devem dar umaespecificação exata de como o mecanismo de testes de tipos deve ser aplicado.

Existem duas definições de noções de compatibilidade de tipos:1- Equivalência de nomes: Duas variáveis possuem tipos compatíveis

se têm o mesmo nome de tipo, definido pelo usuário ou primitivo, oude aparecem na mesma declaração.

2- Equivalência estrutural: Duas variáveis têm tipos compatíveis sepossuem a mesma estrutura.

4.6.3 Ponteiros

Ponteiros começaram a ser criticados em meados da década de 1970. Assim como os goto’s irrestritos alargam o contexto a partir do qual umainstrução rotulada pode ser executada, ponteiros irrestritos alargam o contextoa partir do qual pode-se Ter acesso a um dado.

Ponteiros compreendem a ferramenta básica fornecida para serepresentar dados definidos recursivamente. Como um mecanismo delinguagem de baixo nível, contudo, podem ser usados para outros propósitos

além dos originalmente pretendidos. Podem tornar os programas menoscompreensíveis e, freqüentemente, inseguros por várias razões, entre elas:violações de tipos, acesso a áreas de dados não alocadas.

5 Estruturas de Controle

5.1 Nível de Comando

Existem três tipos de estruturas de controle a nível de comando:Seqüencial, Seleção e Repetição.

Estruturas de controle neste nível contribuem sensivelmente para alegibilidade e a menutenibilidade de programas.

5.1.1 Controle Seqüencial

Mecanismo de estruturação mais simples existente em linguagens. Éusado para indicar que a execução de um comando (B) deve seguir aexecução de um outro comando ( A). De modo geral, pode ser escrito como “ A;

B”, onde “;” denota o operador de controle seqüencial. As linguagens provêem





formas de agrupar comandos de uma seqüência, dito “comando composto”(exemplo: Pascal begin e end e em C { e }).

5.1.2 Controle de Seleção

Estruturas de controle permitem ao programador especificar que umaescolha deve ser feita entre um certo número de comandos alternativos.

Exemplo:Os comandos: if then else;

case;if then elifthen ... elifthen else endif;switch case.

5.1.3 Controle de Repetição

A maioria dos programas úteis envolvem a repetição de um número deações. Em conseqüência disso, todas as linguagens de alto nível possuemestruturas de controle que permitem a especificação da execução repetida deum conjunto de instruções.

Exemplos:

do{ bloco } while(boolean);while(boolean){ bloco };

for (cont; boolean;...){ bloco}

5.1.4 Estruturas de Controle Definidas pelo Programador

Existem linguagens que proporcionam um grau de abstração aindamaior, permitindo ao programador o uso de variáveis de controle de qualquer

tipo abstrato e fornecendo mecanismos para a especificação da seqüência devalores para uma variável de controle. Estas linguagens podem ser chamadasde extensíveis, porque o programador pode aumentar a linguagem de basepela definição de novos tipos (abstratos) de dados, novas operações (comprocedimentos) e também novas estruturas de controle.

Exemplo: na linguagem CLU

for atomo : no in lista( x ) do executa ação no atomo


Condições de parada lógica

Condições de parada via iterador




5.2 Estrutura de Controle a Nível de Unidade

Estas estruturas são mecanismos para a especificação do fluxo de

controle entre unidades de programa. O mecanismo mais simples cria novoambiente de referência e é executado quando encontrado no processamentoseqüencial. Mecanismos mais poderosos permitem ao programador atransferência de controle entre unidades por meio de chamadas explícitas.

Existem duas formas de transferir o controle entre unidades(sub-programas). Uma forma é dita explicita, e acontece quando uma unidadeespecifica pelo nome a chamada de uma outra unidade, desta forma a unidadechamada é dita implícita. Comumente isso acontece quando a transferência docontrole é feita sem especificar a unidade chamada (exemplo: tratadores deexceções).

5.2.3 Unidades Subordinadas Chamadas Explicitamente

Esta classe cobre os sub-progamas, desde as sub-rotinas e funções eprocedimentos.

A passagem de parâmetros permite a comunicação de dados entreunidades de programa. Ao contrário do que ocorre com variáveis globais,parâmetros permitem que dados diferentes sejam passados a cada chamadada unidade, e oferece vantagens nos pontos de vista de legibilidade emodificabilidade de programas.

A maioria das linguagens de programação usam critérios posicionais emétodos alternativos para a amarração de argumentos e parâmetros emchamadas de unidades.

As entidades que podem ser passadas como parâmetros podem ser divididas em três classes: dados, sub-programas e tipos.

5.2.3.1 Dados Como Parâmetros

Existem convenções diferentes para a passagem de parâmetros parasub-programas. Entre estas convenções estão:

- Passagem de referência (ou compartilhamento) A unidade chamadora passa para a unidade chamada somente oendereço do parâmetro.

- Passagem de cópiaNeste mecanismo parâmetros não compartilham memória comargumentos, em vez disso, eles se comportam como variáveislocais.

-

Passagem de nome





Como na passagem de referência, um parâmetro denota umaposição no ambiente da unidade chamadora, não sendo umavariável local.

5.2.3.2 Sub-programas como Parâmetros

A passagem de sub-programas como parâmetros é útil em muitassituações práticas. Por exemplo, um sub-programa S que avalia propriedadesde funções de uma variável em um intervalo dado [a..b] pode ser escrito sem oconhecimento da função, e pode ser usado para diferentes funções se osvalores da função são produzidos por um sub-programa que é enviado a Scomo um parâmetro. Como um outro exemplo, se a linguagem não proporcionamecanismos explícitos para o tratamento de exceções, um sub-programatratador de exceções pode ser transmitido como parâmetro à unidade que podeacusar a exceção.

A transferência de um sub-programa como parâmetro requer pelo menosa passagem de uma referência ao seguimento de código do argumento.Entretanto, o sub-programa sendo passado também pode acessar variáveisnão locais e, assim, é também necessário passar informação sobre o ambientenão local do argumento.

6 Introdução ao Paradigma Funcional

6.1 História da Programação Funcional

A história da programação funcional inicia-se antes da invensão doscomputadores. No princípio do Século XXI muitos matemáticos estavampreocupados com as teorias dos infinitos (conjuntos) entre estes matemáticosestava Giusepe Peano (1858-1932), que mostrou que os números naturaispodem ser obtidos: era finitas operações de aplicação da função sucessor, estateoria também foi mostrada por Thoralf Skulem (1887-1963) via operaçõesrecursivas semelhante o teorema de Peano. Assim, podemos identificar que

nas primeiras décadas do Século XX já surgiram as primeiras definições defunções de números naturais e recursão.

Por volta de 1930 com a evolução da matemática, houve váriastentativas de formalizar a notação de constructibilidade (também conhecidocomo “effective calcul abelity” e “computability”). Entre estas formalizações omais famoso foi a definição de Turing também conhecido como Máquinas deTuring. Outra aproximação baseada nos trabalhos de Stalem e Peano, foiFunções Recursivas Gerais proposto por Godel em 1934. Uma terceiraaproximação teve rumo direto à programação funcional, que foi o cálculo“Lambda” desenvolvido por Church Kleene no início dos anos 30. Muitasoutras aproximações, tais como, algorítmos de Morkov e “Post Productions





Splem” foram desenvolvidos ao mesmo tempo, todas com formulaçõesindependentes e de compatibilidades equivalentes.

Na década imediatamente precedente à invenção dos computadores

digitais, investigações com funções recursivas lógicas e matemáticas,mostraram que qualquer função computável pode ser expressado nas funçõesrecursivas.

Outro passo importante na história da programação funcional foi otrabalho de John McCarthy, que em 1958 estudou o uso de listas ligados comfunções recursivas e passagens de funções com parâmetros de outrasfunções, juntando estas idéias para posteriormente implementar umalinguagem que ficou conhecida como LISPI, foi descrita em um artigo , escritapor ele mesmo em 1960, “Recursive Functinons of Symbolic Expressionsandtheir Computation by Machine”. Isso pode ser visto como o início daProgramação Funcional.

No fim dos anos 60 e início dos anos 70 trouxe um aumento da atençãodos pesquisadores para a até então chamada programação aplicativa. Em1978 quando John Backus publicou um “paper” criticando severamente aslinguagens de programação convencional. Backus que foi o principal inventor do FORTRAN, e propondo o desenvolvimento de um novo paradigma deprogramação. Paradigma, este, chamado de “Programação Funcional”.

6.2 – Linguagens de Programação Funcional (P.F.)

As linguagens de P.F. diferem largamente em seus estilos sintáticos,como poderá ser visto nos vários exemplos de programas em linguagensdistintas. A razão, pelo qual existe essa diversidade nas sintaxes é devido aomotivo das linguagens funcionais serem linguagens experimentais, ou seja, sãoexperimentos com notações.

Uma das síntaxes existentes é a “Syntatic Sugar”, ou melhor, umalinguagem mais conveniente para programa-se um Cálculo Lambda, essalinguagem foi chamada de UNSUGARED LAMBDA CALCULUS (U.L.C.).

Exemplo:

Programação 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 ) ) ) ) ) )





Além 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 notação de Landim surgiram:Miranda (Turner Mirando 1985 b), Scheme, que muito similar ao LISP efinalmente a linguagem F.P. (Dackus 1978).

Exemplo de cada uma destas linguagens, para o seguinte caso:

C n, k = k! .( n – k )! K!

Em φ 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 xC ( x , 6 )

28

let E ( P , Q ) ≡ P x E ( P , Q – 1 ) , if P > 0E ( P , 0 ) ≡ 1

Em Scheme ( combinação )( 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 ) )( C x 6 )

28

Em FPDef 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 >





6.3 – Definição de Função

Para programar com função, devemos primeiro considerar os caminhos,

pelos quais, as funções podem ser definidas. Matematicamente uma função éexatamente um conjunto de pares de entrada e saídas. Portanto, um caminhopara definir a função é enumerar esses pares. Por exemplo, a definição dafunção not

Not true ≡ falseNot false ≡ true

De forma similia a definiçãoda função or Or (true, true) ≡ trueOr (true, false) ≡ trueOr (false, true) ≡ true

Or (false, false) ≡ false

Desta forma pode-se observar que este caminho não é aplicável afunções complexas, método chamado de enumerative definition. Um outrocaminho é chamado de definition by composition, que consiste em definir umafunção através da composição de outras já prontas.Exemplo:

Implica (x,y) ≡ ou (not x,y)Que define a função implica, pela composição das funções or e not. Assimreduzindo a complexidade da definição da função.

Outra forma de x definir funções é na recursividade. Por exemplo, sefossemos definir uma função multiplicação , “x”, em termos de composições dafunção soma, “+”, obteríamos infinitas condições de tipo:

m * n

φ ; sem=φn; se m=1n+n; sem=2

n+n+n; sem=3

Portanto torna-se impossível fechar o problema, devido ao fato de nãose conseguir prover todas as condições possíveis desta forma. Então paracontornar esse problema, podemos definir essa função através da composição dafunção soma e aplicação dela nela mesma. Caindo, assim, em um processorecursivo, da seguinte forma;

m * nφ ; se m=φn+(m-1)*n; sem>φ





É importante também, distinguir entre funções explícitas e definiçõesimplícitas:

EXPLÍCITAS: São aquelas definições, que as variáveis que aparecem do lado

esquerdo das equações, não aparecem do lado direito.Ex.: y = 2ax

IMPLÍCITAS: São aquelas definições em que as variáveis aparecem em ambosos lados da equação.Ex.: f (x) = f( g ( x ) );

Resumindo, funções recursivas são, em suma, de definiçõesimplícitas; ou seja, não podem ser resolvidas diretamente enquanto asexplícitas podem.

6.4 Conceito de Programação Funcional

Programação em uma linguagem funcional consiste em construir definições e usar o computador para avaliar expressões. A função primária deum programador é construir uma função (algoritmos) para solucionar um dadoproblema. Esta função pode envolver um número de funções subsidiárias, edeve ser escrita em notação que obedece os princípios matemáticos normais. A função primária do computador é agir como um avaliador ou calculador: seu

serviço é avaliar expressões e imprimir resultados. Neste respeito, ocomputador afe semelhante a uma simples calculadora de bolso. O quedistingue o cálculo funcional de uma simples calculadora é a habilidade doprogtramador de construir definições para aumentar a sua força de cálculo.Expressões que contém ocorrências de nome de funções definidas peloprogramador são avaliadas pelo uso de dadas definições como regras desimplificação (ou “redução”) para converter estas expressões para a sua formamais simples (produzir resultados).

6.5 Redução de Expressão

O computador avalia uma expressão pela redução para a sua “formaequivalente simplificada” e imprimindo o resultado. Os termos avaliação,simplificação e redução são usados para descrever este processo. Paraexemplificar como esse processo de redução ocorre dentro do computador,tomemos a expressão:

Square ( 3 + 4 )Vamos avaliá-la pelo processo de redução. Uma possível seqüência de

redução 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 Introdução à Linguagem Scheme

7.1 – Sobre a linguagem

Scheme é um dialeto da linguagem LISP. Tendo herdado do LISP tiposde dados latentes (ou dinamicamente checados), interface interativa com ousuário, gerenciamento de armazenamento automático e uso de ordemaplicativa de avaliação de argumentos.

Scheme oferece recursividade de calda. Portanto, executar umprocedimento com recursividade de calda dispensa controle de espaço depilha. Assim permitindo contrair-se procedimentos recursivos comcomportamentos interativos, sem perder a eficiência.

Devido a simplicidade e elegância, o Scheme, tem sido largamente

usado para fins educacionais. Prometendo, para o futuro significante impactona ciência da computação em termos de pesquisa, principalmente no que dizrespeito à programação paralela e inteligência 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 ) ) ) )

7.2 Sintaxe da Linguagem

Neste ponto serão feitas comparações entre as sintaxes de LISP eSCHEME, sob diversas situações:

A. DECLARAÇÕES

Scheme Lisp

( define x E )( define ( f x ) E ) ( defconst x E )( defun f ( x ) E )


x * ( fac ( - x 1 ) )




( define ( f x1 ... xN ) E )( let ( ( x1 E1 )

( ( x2 E2 )

( ( xN EN ) ) E )

( defun f ( x1 ... xN ) E )( let ( ( x1 E1 )

( x2 E2 )

( xN EN ) ) E )

( letrec ( ( f 1 ( lambda ( p1 ) E1 ) )

( f N ( lambda ( pN ) EN ) ) )E )

Labels ( ( f 1 ( p1 ) E1 )

( f N ( pN ) EN ) )E )

APLICAÇÕES E ABSTRAÇÕES

Scheme Lisp

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

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

BOOLEANAS

Scheme Lisp# t # f ou ( )( not E )( and E1 E2 )( or E1 E2 )( eq E1 E2 )( not ( eq E1 E2 ) )( if B

TF )

( cond ( B1 T1 )( B2 T2 )

( else F ) )

t , Nil( not E )( and E1 E2 )( or E1 E2 )( eq E1 E2 )( not ( eq E1 E2 ) )( if B

TF )

( cond ( B1 T1 )( B2 T2 )

( T F ) )

7.3 Números

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

( not ( = E1 , E2 ) )

( + E1 E2 ... EN )( * E1 E2 ... EN )( truncate ( E1 E2 ) )( expt E1 E2 )< , <= , = , >= , >

( / = E1 E2 )





7.4 String

Scheme Lisp“ C C C C ... C C “( string = ? E1 E2 )( list string L )( string list E )( length E )

“ C C C C ... C C “( string = E1 E2 )( coerce E ‘string )(coerce E ‘list)

?

7.5 Seqüências

Scheme Lisp‘ ( e1 , e2 , e3 ... eN )( list E1 E2 ... EN )

‘ ( )( car L ) cabeça( cdr L ) resto( cons e L ) insere na cabeça( length L )( member e L )( reverse L )

( cadr L )( append L1 , L2 , ... LN )

‘ ( 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 )

7.6 Funções Finitas

Scheme Lisp‘ ( ( x1 y1 ) ... ( xN yN ) )( list ( list E1 F1 ) ... ( list EN FN )‘ ( )( cadr ( assoc x L ) )

( map car L )

‘ ( ( 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 F E )( lambda ( x ) K )

( map car F E ) , ( map “list F E )# ‘( lambda ( x ) K )





8 Desenvolvimento de Funções Básicas em Scheme

8.1 Constantes e funções simples:Uma constante é definida da seguinte forma:

(define < contstant_name> < constant_value>)

E para avaliar esta constante basta digitar o nome da constante definidana linha de comando do interpretador.

Uma função qualquer é definida da mesma forma que uma constante,porém com uma ressolva do programa de parâmetros.

Seguindo, basicamente modelo abaixo:(define < function_name parameters> < function_developments>)

Para avaliar uma função deve-se digitar o nome da mesma com osdevidos parâmetros, entre parênteses, na linha de comando dointerpretador.

Exemplos de funções e constantes:

Constantes:

PI ( define PI 3.14159216 )

Verdadeiro ( define verdadeiro # t )Falso ( define falso # f )

Funções:

( 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 ) ) ) ) )

Ex: ( 10 15 20 )





20 Depois o 20 sai, gera( m ( 20 ) ) pendência (?), e faz tudo( m ( 15 20 ) ) If ( > 15 ? ) 20 de novo com o 15, depois

( m ( 10 15 20 ) ) If ( > 10 ? ) com o 10

8.2 Algoritmos Recursivos

Algoritmo da seqüência de Fibonacci1 , 1 , 2 , 3 , 5 , 8

• Que ativam processos recursivos( define ( fib n )( if ( < n 3 )1

( + ( fib ( - n 1 ) ) ( fib ( - n 2 ) ) ) ) )

1= ( fib 1 )1= ( fib 2 )2= ( fib 3 ) ( + ? 2 = 1 ? 1 = 1 )1= ( fib 2 )1= ( fib 1 )1= ( fib 2 )2= ( fib 3 ) ( + ? 2 = 1 ? 1 = 1 )

3= ( fib 4 ) ( + ? 3 = 2 ? 2 = 1 )5 = ( fib 5 ) ( + ? 4 = 3 ? 3 = 2 )

Exercício

Elaborar um algoritmo em SCHEME para, dada uma lista de números inteiros,devolver o somatório dos números da mesma.

Exemplo: L = ( 5 10 8 12 20 )( somatório L ) 55

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 )





( if ( null ? L )0

( + ( car L ) ( somat ( cdr L ) ) ) ) )

Ex:0 5 ( )

20 5 ( 20 ) ( + 20 0 ) = 2032 5 ( 12 20 ) ( + 12 20 ) = 32 PILHA10 5 ( 8 12 20 ) ( + 8 32 ) = 4050 5 ( 10 8 12 20 ) ( + 10 40 ) = 5055 5 ( 5 10 8 12 20 ) ( + 5 50 ) = 55

• Que ativam processos iterativos( define ( fib I n )

( if ( < n 3 ) 1( fib I_aux n 1 1 ) ) )

( define ( fib I_aux n f 1 f 2 )( if ( = n 3 )( + f 1 f 2 )( fib I_aux ( - n 1 ) ( + f 1 f 2 ) f 1 ) ) )

8= ( fib I 352 )( fib I 432 ) ?( fib I 521 ) ? xY = z( fib I 611 ) ?

8= ( fib I 6 ) ? = 8

8.3 – Manipulação de listas em Scheme

Lista são sequencias de zero ou mais valores. Em schieme uma lista érepresentada por elementos entre parênteses. A lista vazia ou nula érepresentada por ( ), ou seja, uma lista com zero elementos. E parainformar ao interpretador que o conteúdo entre parêntese é uma lista, deve-se colocar um apóstrofo (QUOT) parafraseando o abre parêntese.Exemplo:

‘( ( ( Exemplo ) de ) ( uma lista ) em ( scheme ) )





operações com listas

( define x ‘( ( ( exemplo ) de ) ( uma lista ) em ( scheme ) )

Linha de Comando Equivalente ResultadoX x a própria( 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 Notação Lambda

esta anotação foi introduzida na linguagem para manter o padrão da

anotação do cálculo lambda. Também é usada para definir funçõestemporárias sem nome, internas a outras funções.Exemplos:( define ( square x ) ( * x x ) ou ( define square ( lambda ( x ) ( * x x) ) )

Exercícios

1 - Construa uma função para devolver o produto cartesiano entre duas listas

representando valores, conforme exemplo:

( prod_cart ‘( 1 2 3 4 ) ‘( 5 6 7 8 9 ))

( ( 1 5 ) ( 1 6 ) ( 1 7 ) ( 1 8 )( 2 5 )

( 4 5 ) ( 4 8 )


recursivo e iterativo




2 - Dado um número inteiro qualquer, confeccionar uma função para verificar

se o número é primo ou não :

Ex.: ( primo ? 10 )#f

( primo ? 11 )# t

3 - Elabore uma função para calcular o produto interno entre duas listasrepresentando vetores de tamanhos iguais.

Ex.: ( prod_int ‘( 1 2 3 ) ‘( 4 5 6 ) )( 5 7 9 )

4 - Dada uma matriz qualquer, faça uma função para calcular a determinanteda mesma.

Ex.: ( Determinante # ( 1 2 3 )( 2 3 1 )( 3 1 2 )6 + 6 + 6 - ( 27 + 1 + 8 )

18 - 36 = -18

manipulação 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 função em scheme para permutar dois elementos em umalista

Ex.: ( permuta 1 2 ‘( 1 2 3 )) ‘( 2 1 3 )RecursivoIterativo

6 - Faça uma função scheme para ordenar uma lista, utilizando o método daordenação por seleção.





Ex.: ordenação por seleção

Início : d c a b

1º passo : a c d b permuta o menor elemento com o primeiro da lista2º passo : a b d c permuta o menor da calda lista com o primeiro da caldada mesma.3º passo : a b c d permuta o menor do cddr da lista com o primeiro docddr da mesma e assim por diante.

7 - Faça um algoritmo em scheme para contar os elementos repetidos entreduas listas dadas l1 e l2.

Recursivo

Iterativo

8 – Construa uma função para devolver a união, da teoria deconjuntos, entre duas listas dadas.

IterativoRecursivo

9 – Elabore um algoritmo de ordenação para uma dada lista, usando o métododa inserção.

10 – Desenvolva uma função para devolver a permutação de doiselementos de uma dada lista.

Recursivo

Iterativo

11 - Elabore um algoritmo de ordenação para uma dada lista, usando o métododa seleção.

12 - Construa uma função em Scheme para ordenar uma lista dada, usando oalgoritmo do Quick Sort.





9 Introdução à Programação Orientada a Objetos

Inicialmente é interessante dar significado às seguintes interrogativas:

O que é objeto?

R.: Objeto => representa uma entidade do problema, a qual estão associados:- um conjunto de estados (características, atributos, etc...)- um conjunto de operações que podem ser aplicadas a objeto

Exemplo: Objeto triângulo• Estados: medida dos lados, área, classificação, etc...

• Operações: desenvolver – triângulo, preencher – triângulo, rotacionar –triângulo, etc

Porque programação O.O. difere das programações convencionais?

R.: Programação Tradicional X P.O.O.: Programação O.O. diferefundamentalmente da Tradicional. P.O.O. trata o problema em termos dosobjetos envolvidos e a Programação Tradicional trata os problemas em termosde suas funcionalidades (abrangem Top e Dowm).

Programação O.O. é mais facilmente descrita como programação por

simulação. A metáfora programação é baseada na personificação dos objetosfísicos ou conceituais de algum domínio do mundo real em objeto no domíniodo programa.

Outra expressão que merece uma atenção especial é: “Orientado aObjeto”, a qual é intrinsicamente despronda de significado, ou seja, não possui,ainda classificação definida pela indústria de software, porém poderíamosdefini-la com auxílio de dicionário, da seguinte maneira.

- Dirigida para qualquer coisa que se possa pensar

E no sentido computacional pode-se dizer que orientado objeto sedefine pelas seguintes propriedades:

- Encapsulamento- Ocultamento de informações/implementação- Retenção de estado- Identidade de objeto- Mensagens- Classe- Herança- Polimorfismo- Genericidade





9.1 Conceitos Básicos

Objeto: um componente do sistema representado por algum dado privado e o

conjunto de métodos.

Método: é a especificação (detalhadamento) de como uma mensagem éimplementada.

Instância: um objeto individual descrito por uma classe particular.

Classe: uma descrição de um conjunto de objetos com características eatributos similares. Em outras palavras, são entidades que definem um padrãode comportamento e estados para objetos a ela pertencentes .

SuperClasse: é uma classe contendo generalizações de classes derivadas.

Subclasse: é uma especificação de uma SuperClasse, estendendo-a comalgumas características adicionais (comportamento e novos estados) .

Herança: é um mecanismo específico pelo qual uma instância de umasubclasse herda toda a representação e comportamento de suas super classes.

Mensagem: um requisito enviado para um objeto, obtendo como resposta

algum serviço.

Seletor: o componente de uma mensagem que unicamente especifica aoperação requisitada.

Receptor: instância que recebe uma mensagem qualquer.

9.2 Características 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 aum certo protocolo, que é definido como um conjunto de mensagens quepodem ser enviadas para um determinado objeto.

Exemplo:Objeto: CACHORROProtocolo:

LATIRMOVIMENTARDEITAR

Estados:

EMOÇÃOPESOIDADE





• Conjunto de mensagens que o objeto cachorro pode receber: LATIR,MOVIMENTAR, DEITAR;

Qualquer outra o objeto não pode responder pois não pertence a seu protocolo.No caso do vídeo game:

Objeto: BOLAProtocolo: POSIÇÃO ?

DIREÇÃO ?MODIFICAR_POSIÇ ÃO ALÉM_BASE ? ATRÁS_BASE ?

Estados: POSIÇÃODIREÇÃO

P.O.O. é programação por classificação. No mundo real é comum nosdepararmos com estruturas hierárquicas definindo classes e objetos como por exemplo:


Atrás - Base!

Modificar - Posição : Nova - Posição

c

c

Bola Receptor Seletor Argumento

Vegetal

SeresVivos

Animal

Mamíferos Aves

Superclasse

Subclasse




• Uma superclasse que não define comportamento de objetos inerentes doproblema é chamado de abstrata.

Uma das características 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: CÍRCULO QUADRADOProtocolo: DESENHAR

AJUSTARPOSICIONAR

DESENHAR AJUSTARPOSICIONAR

Estados: POSIÇÃORAIO

POSIÇÃOTAMANHO_LADOS

• Logo as mensagens desenhar, ajustar e posicionar, possuem nomes iguais

para os dois objetos, porém possuem códigos distintos, caracterizando opolimorfismo.

Muitas vezes pensamos em objetos com características em comunscom outros objetos, como por exemplo:

Vemos então a hierarquia dos polígonos, começando da classe Polígonoderivando em Quadrilátero e e Retângulo, que são subclasses de polígono.Desta forma, definidas, as instâncias das subclasses herdam as característicasdas superclasses. Isso em P.O.O. é denominado programação com herança.

A programação com herança é de extrema importância pelo motivo doreaproveitamento das definições semelhantes dos objetos que derivam dassuperclasses (reaproveitamento de códigos).


Polígono

Quadrilátero Triângulo

Quadrado

Retângulo




10 Introdução à Linguagem Smalltalk

Smalltalk é mais do que uma simples linguagem de programação é umcompleto ambiente de desenvolvimento de programas, integrado em ummétodo consistente, de modo que aplicativos como editar, compilador,debugger, checador de queda, utilitários de impressão, sistema de janelas egerenciador de código origem estão embutidos no sistema. Geralmente, taisaplicativos estão associados a um sistema operacional, logo o smalltalk é maisdo que simplesmente uma linguagem de programação (melhor) pois elimina ocrucialmente entre o S.O. e a programação, através da modelagem de tudocomo um objeto.

Tornar-se um produtivo programador em SMT requer muito mais que umafamiliaridade com o mesmo. Programação em SMT requer o mínimo o

entendimento dos seguintes assuntos;

• Os conceitos fundamentais da linguagem; isto é: Objetos,Mensagens, classes, Heranças, ...• A sintaxe e a semântica de SMT;• Como interagir com o ambiente de programação SMT, para construir novas aplicações (SMT é uma linguagem interativa que favorece umaprender-fazendo).• Conhecer as classes dos objetos fundamentais dos sistema, taiscomo: Magnitude, Collection, Graphical e classes de interface com ousuário.

Projetar novas aplicações SMT requer um conhecimento da capacidade doSMT. Programação em SMT é muitas vezes dita programação por extensão;ou seja, novas aplicações são construídas através da extensão da biblioteca declasses do sitema.

10.1 Objetos em SMT

Tudo em SMT é objeto, inclusive o próprio sistema. Componentes dossistemas (compilador, debugger), elementos de dados (inteiros, booleanos ecaracteres) e elementos gráficos (áreas retangulares, canetas de desenho ebitmaps), são 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 memória e instruções primitivas ou conjunto de operações. Um

objeto em memória → dados privados ou estado que está retido dentro de um





objeto. Um objeto é capaz de computação → 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" amesma, e se deve responde-la.

Ex.:

umPonto x↓ ↓

Objeto Mensagem

umPonto distanciaDe: outroPonto↓ ↓ ↓

Objeto mensagem Parâmetro

10.1.3 Encapsulamento Informações

Objetos em SMT encapsulam ambos procedimentos e dados. Este artifício

foi incorporado à linguagem, devido ao sucesso obtido nas linguagensestruturadas no controle da complexidade de grandes programas, provido peloencapsulamento.

No controle da complexidade de grandes programas, deve-se particionar osprogramas em módulos . Além disso, deve-se esconder o máximo deinformações possível dentro dos módulos e minimizar a interface a usuários.

Objetos em SMT apresentam dois pontos de vista, os quais são: um parausuários dos objetos e outro para quem implementa os mesmos. Costuma-sechamar estes pontos de vista de: vista externa e vista interna respectivamente. A vista interna descreve a representação e os algoritmos que implementam osmétodos dos objetos. A vista externa é o visual do objeto visto por outros

objetos.

Ex.:

A vista externa ou protocolo de mensagens suportado pelo objetoumPonto.


umPonto

umPonto

x

y

Responde o valor dacoordenada x do objetoumPonto

Expressão em SMT

Responde a distânciaentre um Ponto eoutroPontoumPonto

Expressão em SMT




A separação entre vista interna e vista externa de um objeto é fundamental nafilosofia de programação embutida em SMT. Para usar um objeto, é necessárioentender 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 são usados para descrever números, símbolos, caracteres,strings e arrays.

Smalltalk 34-17.621.5 -e'uma string'# soluções$c#(-25 'uma string' $c)#(10 100 150)

C 34-17.621.5-e"uma string"-'c'-{ 10 100 150}

Comentáriosinteiro 34p.f. -17.62p.f. 0.0015 deforma expsímbolo com o nome soluções(não coexistem)

caracter carray com 3 obj. Não homogêneosarray com obj homogêneos

10.2 Mensagens

Os componentes de uma mensagem são chamados de: RECEPTOR,SELETOR e ARGUMENTOS, respectivamente.

Ex:1 + 5

O inteiro 1 é o receptor da mensagem, + é o seletor que unicamenteidentifica qual operação será escolhida e 5 é o argumento.

O tratamento desta operação em relação a programação tradicional édiferente:

Tradicional O.O.

6 6


+

51

1

+ 5

operador

operandos




SMT suporta três tipos primitivos de mensagens, conhecidas, como:UNÁRIA, BINÁRIA e KEYWORD.

9.2.1 Mensagens Unárias

São aquelas mensagens que na sua expressão não possui nenhumargumento.

Ex:'letras minúsculas' asUpperCase#(4 3 2) reversed$c asciiValue38 asCharacter

10.2.3 Mensagens Keyword

São mensagens com um ou mais argumentos. Estas mensagens sãocaracterizadas por possuir sempre o caracter " : " (dois pontos) como parte donome do seletor da mesma.Ex:

'caracter na posição' 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 Binárias

São mensagens com somente um argumento e 1 ou 2 caracteres especiaiscom 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 Aritméticas

São, na maioria das vezes mensagens binárias.





Ex:

5 * 7 Multiprogramação5 // 2 Divisão inteira

4 \\ 3 Resto da Divisão2 / 6 Divisão racional (resposta na forma reduzida).

A avaliação de expressões é feita da esquerda para direita, não havendoprecedência entre operadores.

Exemplo:5 - 3 * 7 (resultado = 14)

10.2.5.2 Mensagens Dentro de Mensagens

Expressão'TAMANHO' size + 4'três' size + #(1 2 3) size2 factorial negated15 gcd : 3//35 between: 1 and: 3 sqwared + 44 factorial gcd: 4*6

Parentizada('Tamanho' size) + 4 = 11( ('três' 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

Precedência das Mensagens

1- Parentizada2- Unária (avaliadas da esquerda para direita)3- Binária (avaliadas da esquerda para direita)4- KeyWord

10.2.5.3 Mensagens em Cascata

É uma maneira concisa de especificar que multiplas mensagens serãoenviadas para um mesmo receptor. As várias mensagnes são separadaspor “ ; “ (ponto e vírgula).

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 últimamensagem. Para verificar o resultado de todas as mensagens a última

mensagem deve ser yourself.





Ex:umArray at:1 put:3 ; ... ; yourself.

10.2.6 Variáveis Temporárias

Devem ser declaradas na primeira linha de uma série de expressões,delimitadas por barras verticais (pipes). Devem iniciar com letras minúsculas epodem 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 comparação de objetos< "menor";> "maior";<= "menor ou igual";>= "maior ou igual";= "igual";~ = "diferente".

Teste de Objetos:isUpperCase "é minúsculo";odd "é ímpar";isVowel "é vogal".

Expressões condicionaisifTrue: , ifFales: e ifTrue:ifFalse

Exemplo:<expr.boll.> ifTrue:[bloco de programa]

<expr.boll.> ifFalse:[bloco de programa]





ou<expr. boll.>

ifTrue: [bloco de programa]

ifFalse: [bloco de programa].

Expressões booleanasor: , and: , not: , ... , mensagens de comparação

Exemplo:<expr. bool.> or: [bloco booleano].<expr. bool.> and: [bloco booleano].<expr. bool.> not: [bloco booleano].

Mensagens de repetição

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_numérico timesRepeat:[bloco de programa].

10.2.8 Iteradores

Os iteradores são mensagens para serem enviadas para objetos da classeCollection (somente) as quais servem como comandos de 'loop'.De forma que, para cada elemento pertencente à coleção em questão, amesma executa um bloco de programa em SMT e estõ divididas em quatrotipos diferentes, de acordo com o tipo de resultado retornado, são elas:

• O Iterador do:

Este iterador não retorna nenhum tipo de objeto (nil).

Exemplo:"Contagem do número de caracteres vogais dentro de uma string"| vogais |vogais := 0.uma string contendo vogais 'do : [char |

char isVowelifTrue: [vogais := vogais + 1]].

^vogais

• O Iterador select





Retorna um objeto da mesma classe do objeto que está recebendo amensagem, logo o resultado também é uma coleção.- Coleção de objetos que satisfazem uma condição booleana interna ao bloco

executado.

Exemplo:"Conta o número 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 mesmaclasse do receptor da mensagem. Porém, agora contendo aqueles elementosque não satisfazem a expressão booleana.

Exemplo:"Retorna aqueles objetos cujo valor dele à 4º potência 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 coleção de resposta todos os resultadosde execução do bloco de programa.

Exemplo:"Devolve, para um array se inteiros o quadrado dos números 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 Exercícios

1 - Comente com suas palavras sobre programação por classificação.

2 - Cite as principais vantagens da programação com herança(Múltipla /Simples).

3 - Diga onde você enxerga encapsulamento em POO.





4 - Para cada expressão abaixo parentize-a de acordo com a ordem deexecução 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 são os parâmetros de cada mensagem- Qual é o resultado final

A) #(5 7 8 10) at:2 + 'vetor' size-4B) #(5 6 7) at:5 factorial //$t ascciiValueC) 2 + 2 * 3.25 // 2 \\ 10.D) 'str' size between:5 and: 10 exp //10e3obs..: Se em algum caso acima a expressão acusar erro, parentize-a de forma

que corrija o erro e responda os itens.

5 - Faça utilizando um iterador, uma forma para calcular a média aritmética dosnúmeros contidos em um array qualquer (o array não contém somentenúmeros, considerar só os números).

6 - Faça um algorítmo, para dada uma string pertence à primeira.

7 - Faça um algorítmo para, dado um array contendo objeto diversos (dediversas classes), devolver um outro array contendo vários outros arrays deforma que nestes arrays internos contenham somente objetos da mesmaclasse e colocar o nome da classe dos objetos contidos no array interno, na 1ªposição dos mesmos.Ex:

#('str' 2 #(10 20) $e $b 5)retornar:#(#('String' 'str') #('smallInteger' 2 5)#('Array' #(10 20)) #('character' $e $b))

10.3 Implementação de Classes e Métodos

9.3.1 Classes

Solução de problema usando smalltalk envolve classificação deobjetos de acordo com sua similaridades e diferenças.

Ex:#(‘Maria’ ‘Joana’) class (Instância da classe Array)‘uma string’ (lass (Instância da classe string)Turtle class (Instância da classe Pen)





Variáveis internas de um objeto são chamadas variáveis de instância.Por exemplo: objetos da classe Fraction tem as variáveis de instâncianumerator edenominador.

10.3.3 Métodos

Métodos são códigos em smalltalk, o algoritmo que determina todocomportamento e performance do objeto quando uma mensagem éenviada para um objeto, um método é avaliado e um objeto éretornado como resultado.

Ex1:

(1/7) numerator

Quando esta mensagem é enviada, o seguinte método é executado:

numerator ^numerator

Ex2:(2/3) * (5/7)

Método executado:

*aNumber ^(numerator * aNumber numerator) / (denominator * aNumber Denominator).

Na construção de método sempre a primeira linha define o nome do mesmoe na frente do nome vem seus argumentos (quando houver) a partir dasegunda linha vem o desenvolvimento do método.

10.3.4 Class Herarchy Brauser

Para programar em SMT pode-se usar uma janela especial chamada ClassHerarchy Brauser. Ela é dotada da capacidade de mostrar e modificar definições de classes e métodos exigentes e ainda criar novas classes comseus métodos. Pode ser acessada via menu do sistema ou da forma que segueabaixo:

Class Herarchy Brauser newOpen on: (Array with: Integer

with: Fractionwith: String ).

Criado por Marcelo Fernandes dos Santos 67Painel deClasses

Painel deVariáveis

Painel deMétodos

Painel deCódigo

Painel de Escolha




Class Hierachy Browser

Fraction Instance

Integer ClassString Vars

10.3.5 A variável especial “ self ”

Adicionando o seguinte método na classe Fraction, temos:

Fraction“ responde a parte fracionária do número”^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 Criação de novos objetos e o objeto especial “nil”

A maneira já conhecida de criar objetos, até então conhecida é a literal, por exemplo:

‘uma ‘,’string’(1/3)

Mas como classes também são objetos, logo podem receber mensagenstambém. O caminho mais prático de se criar objetos é enviando mensagenspara classes tais como:

Array new: 10.(cria um objeto da classe Array com 10 por onde todas asposições contém o objeto especial nil)

Array new (cria um objeto da classe Array).Pen newDate TodayTime now.O objeto nil pertence a classe UndefinidObject. Ele é uma variável de

instância de todo novo objeto.





10.3.7 Variáveis de Instância

Objetos podem conter ambas named e indexed variáveis de instância.

Variáveis de instância named são acessadas pelo nome, tal como numerator para objetos fraction. Já a indexed são identificadas por inteiros iniciando com1, tal como : ‘ localização’ at:2; ‘parts’ at:5 put: $y.

10.3.8 Recursão

Exemplos:

Fatorial

“devolve o fatorial do receptor”self > 1

ifTrue: [^(self –1) fatorial * self].Self < 0

IfTrue: [^self erros: ‘número negativo’].^1.

Fibonacci“devolve o n-esimo termo da sequencia de fib. Onde n é o

receptor ”

^self < 3ifTrue: [1.] ifFalse[(self –1) fibonacci + (self –2) fibonacci.].

Exercícios

1 - Faça um Método em SMT para calcular a média dos números contidos emum Array de inteiro, os quais estejam entre dois limites dados. Ex.: #(1 2 3 4 56 7 8 9) mediEntre: 4 e: 8

2 - Desenvolva um Método para calcular o n-ésimo número da seqüênciaabaixo: 1 1 2 6 24 120 720 ... a qual é dada pela seguinte fórmula ni =ni-1 * i -ni -2 * (i-2) 5 serie 24





10.3.9 Criação de classes completas

Suponhamos a proposta de construirmos uma classe para os númerosComplexos.

Number subclass: #ComplexoInstanceVariableNames: ‘realPart imaginaryPart’.ClassVariableNames: ’ ’ . “class Methods”novoComplexo: parteReal e: parteImaginaria

“retorna uma instância inicializada da classe complexo”|umComplexo|umComplexo := Complexo new.umComplexo realPart: parteReal;

imaginaryPart: parteImaginaria^umComplexo

“instance Methods”realPart imaginaryPart^realPart ^imaginaryPartrealPart: realValue imaginaryPart: imaginaryValue

realPart := realValue imaginaryPart := imaginaryValue+ umComplexo| realSum imagSum |realSum := realPart + umComplexo realPart.ImagSum := imagPart + umComplexo imaginaryPart.^Complexo novoComplexo: realSum e: imagSum

Exercício

Construa o método da multiplicação, *, para um objeto da classe Complexo.

10.4 Descrição da Classe Collection

A classe collection é uma das mais importantes classes primitivas do SMT.


( a + bi ) * ( c + di )ac + adi + bci + bd

( ac + bd ) + ( ad + bc ) i

Ex:




Arquitetura da Classe

CollectionBagIndexedCollection

FixedSizeCollection ArrayBitmap

Compiled MethodFile Control Black

IntervalString

Simbol

Ordened CollectionProcessSortedCollection

SetDictionaryIdentity Dictionary

MethodDictionarySystemDictionary

SimbolSet

As classes derivada da classe Collection suportam protocolos para :

1 - Efetuar iterações sobre elementos de uma coleção :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 ORDENAÇÃOTAMANHO

FIXO ACEITA

REPETIÇÃOCHAVE DE ACESSO

CLASSE DOSCOMPONENTES

Bag NÃO NÃO SIM - Q.Q.IndexedCollection SIM - - INTEGER -FixedSizeCollection SIM SIM SIM INTEGER - Array SIM SIM SIM INTEGER Q.Q.ByteArray SIM SIM SIM INTEGER SMALINTEGERInterval INTERNO SIM NÃO INTEGER NUMBERString SIM SIM SIM INTEGER CHARACTER

Symbol SIM SIM SIM INTEGER CHARACTERSortedCollection INTERNO NÃO SIM INTEGER Q.Q.





Dictionary NÃO NÃO NÃO CHAVE Q.Q.

11 Problema Proposto

Vídeo Game

ObjectVideo Comp VideoGame

. laterais

Brick MovingComp. x , y. direção. velocidade

Wall . pontos. jogador . parede. ambiente

. posmouse

Ball

- Drawing Mode Constants- Color Constants- Win Constants

Padde . pane. pen. pedal. bola

“Métodos de Instância de Brick”

“ Métodos de Classes de MovigComp”

new : dir posx : px poy : py vel : v| novo |novo := self newnovo direcao : dir; posicaox : px; posicaoy : py; velocidade : vel.^ novo

“ Métodos Instância da Classes MovigComp”

direcao^ direcao

direcao : dir direcao := dir

posicao x^ x

posicaox : pxx := px

posicao y^ y

posicaoy : pyy := py

velocidade^ velocidade





velocidade : velvelocidade := vel.





Apéndice A

1 Programação Orientado a Objeto

A expressão 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 dasseguintes propriedades:

* Encapsulamento* Ocultamento de informação/ implementação

* Retenção de estado* Identidade de objeto* Mensagens* Classes* Herança* Polimorfismo* Genericidade

Para prosseguirmos com as explicações iremos utilizar-se da aplicação Hominídioem miniatura movendo-se em uma grade na tela, como mostrado abaixo.OBS: A sintaxe e semântica não faz parte de nenhuma linguagem, ela é usada apenas paraexplicação.

Descrição do problema:O Hominídio 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 INÍCIO até o quadrado marcado FIM.





Para isso temos duas classes, a classe GRADE e a classe HOMINÍDIO, as quaisutilizaremos para explicações da Programação Orientada a Objeto.

1.1 Encapsulamento

Ë um conceito quase tão antigo quanto o próprio software. Os programadoresobservaram que padrões similares de instruções apareciam várias vezes dentro de ummesmo programa e perceberam que esses padrões repetidos poderiam ser amontoados emum campo do programa e invocados através de um único nome a partir de vários pontosdiferentes no programa principal.

Desta forma nasceu a tão conhecida sub-rotina utilizada em programaçãoestruturada.

O encapsulamento em Orientação a Objeto tem uma finalidade similar àquela dasub-rotina. Mas estruturalmente ele é mais complexo.Resumindo: Encapsulamento é o agrupamento de idéias relacionadas em uma unidade e oencapsulamento orientado a objeto é o agrupamento de procedimentos em torno de dados.

Um objeto consiste em um conjunto de métodos e em um conjunto de variáveis.Cada método é um procedimento publicamente visível, o que significa que ele pode ser chamado por outros objetos.

Variáveis são usadas internamente por um objeto para guardar informações. Oacesso às variáveis e sua atualização são feitos pelos métodos do objeto. Cada variável

está relacionada a um objeto, o que significa que nenhum outro objeto poderá acessá-ladiretamente. Se um outro objeto precisar das informações contidas naquela variável, teráde apelar para um dos métodos do objeto.

Como somente os métodos do objeto podem ler e atualizar as variáveis do objeto,esses métodos formam um anel protetor ao redor do núcleo central de variáveis.

Podemos designar cada método e cada variável do objeto sendo como:* Público - Visível aos outros objetos.* Privativo - Visível somente dentro do objeto.

1.2 Ocultamento de Informação e de Implementação

Podemos enxergar uma unidade encapsulada de fora ( visão pública ) ou de dentro( visão privativa ). O resultado de um bom encapsulamento é a supressão na visão públicade uma variedade de detalhes para serem vistos na visão privativa.

Essa supressão assume duas formas:* Ocultamento de informação - Implica que as informações dentro da unidade não

podem ser vistas de fora da unidade.* Ocultamento de implementação - Implica que os detalhes da implementação

dentro da unidade não podem ser vistos de fora da unidadeO ocultamento de informação contém alguma informação privativa inacessível de

fora. Um exemplo é a direção para a qual está voltado o Hominídio. De fora do objeto





podemos mudar essa informação ( talvez através do método vira-esquerda ), mas não podemos determinar seu valor.

O encapsulamento freqüentemente revela informações, mas esconde a

implementação. Por exemplo, embora o objeto Hominídio nos informe qual é sualocalização ( via método Localização ), nos não sabemos como o objeto armazena sualocalização internamente.

A direção do Hominídio é um exemplo não apenas de ocultamento de informação,mas também de ocultamento de implementação.

O ocultamento de informação e de implementação é uma poderosa técnica paradomesticar a complexidade do software. Isso significa que o objeto aparece como umacaixa-preta a um observador externo.

1.3 Retenção de Estado

A terceira abstração da orientação a objeto refere-se à capacidade de um objeto dereter seu estado. Quando um módulo procedural tradicional ( função, subprograma,

procedimento e etc), retorna ao seu chamador módulo “morre”, deixando apenas seuresultado. Quando o mesmo módulo é chamado novamente ele não se lembra de nenhumvalor anterior, é como se ele estivesse sendo executado pela primeira vez, ou seja, ele nãoguardou nenhum valor do processamento anterior.

Mas o objeto, como o Hominídio, tem “consciência” de seu passado. Ele retéminformações dentro de si mesmo por um tempo indefinido. Por exemplo, um “chamador”de um objeto pode dar a ele um item de informação, e esse chamador - ou qualquer outro

- pode pedir ao objeto que lhe forneça a informação novamente. Em outras palavras umobjeto não “morre” quando termina sua execução, ou seja, ele permanece de prontidão, preparado para entrar em ação novamente.

Por exemplo, o Hominídio retém indefinidamente seu conhecimento do quadradono qual ele se encontra e a direção para a qual ele está voltado.

Encapsulamento Orientado a Objeto, Ocultamento de Informação e deImplementação e Retenção de Estado constituem o núcleo da orientação a objeto.

1.4 Identidade de Objeto

Identidade de objeto é a propriedade segundo a qual cada objeto (independente desua classe ou estado atual) pode ser identificado e tratado como uma entidade de softwaredistinta.

Há algo único ligado a um dado objeto que distingue de todos os outros objetos.Esse “algo único” é proporcionado pelo mecanismo identificador do objeto, queexplicaremos através da análise de uma linha do código do hominídeo:Var hom1:HOMINÍDEO := HOMINÍDEO.new

A parte do lado direito dessa linha cria um novo objeto (da classe HOMINÍDEO),que mostramos na figura 1.6. Note o identificador do objeto, que para o objeto da figura éo número 102237. O identificador é anexado a um objeto quando ele é criado.

Criado por Marcelo Fernandes dos Santos

Vira-esquerda

Vira-direita

Avança

Localização

Coloca-na-grade

Exibe

Frente-parede

Dir loc

102237

Objeto

Manipulador deobjeto3




Duas regras se aplicam aos identificadores:• O mesmo identificador permanece com o objeto por toda sua existência, independente

do que possa acontecer durante esse tempo.• Dois objeto não podem Ter o mesmo identificador.

O lado esquerdo da linha de código é a declaração Var hom1:HOMINÍDEO. Esta éuma declaração normal de programa que dá um nome que tenha significado para o

programador para uma palavra de memória. (figura 1.7).

Ninguém vê o identificador do objeto (102237), apenas trabalha com a variável hom1.Esta variável guarda o endereço de memória de hom1.

Executado uma outra linha similar de código:Var hom2:HOMINÍDEO := HOMINÍDEO.new

Isso criará um outro objeto com o identificador, digamos, 142857, e armazenará

esse identificador na variável hom2( figura 1.8).


Vira-esquerda

Vira-direita

Avança

Localização

Coloca-na-grade

Exibe

Frente-parede

Dir loc

102237

102237

Hom1

Vira-esquerda

Vira-direita

Avança

Localização

Coloca-na-grade

Exibe

Frente-parede

Dir loc

142847

142857

Hom1

4




Para melhor evidenciar, escreveremos uma outra declaração de atribuição assim:Hom2 := hom1

A variável hom2 aponta para o mesmo endereço de memória de hom1 (102234).Só que, não conseguimos acessar mais o endereço de hom2, ou seja, o endereço de hom2

foi perdida.A idéia de dar a cada objeto sua própria identidade através de um identificador

parece inofensiva. Surpreendentemente, no entanto, essa simples idéia causa uma profunda mudança na maneira como projetamos e construímos software orientado aobjeto.

1.5 Mensagens

Um objeto requisita um outro objeto para executar uma atividade através de umamensagem. Uma mensagem típica também direciona algumas informações de um objeto

para outro. Ela é a maneira pela qual um objeto emissor (ob1) dirige para um objeto – alvo (ob2) uma solicitação para que o objeto (ob2) aplique um de seus métodos.

1.5.1 Estrutura de uma Mensagem

Uma mensagem é composta por várias partes sintáticas, cada uma da quais importante àsua própria maneira no projeto orientado a objeto. Para que o objeto (ob1(emissor)) envieuma mensagem sensata ao objeto (ob2(alvo)), o ob1 tem saber três coisas:

1.O identificador de ob2. O ob1 manterá o identificador em uma variável.

2.O nome do método de ob2 que ob1 deseja executar.

3. Quaisquer informações suplementares (argumentos) que ob2 necessitará na execuçãode seu método.

1.5.3 Argumentos de uma Mensagem

Assim como as antigas sub-rotinas, muitas mensagens passam e retornam argumentos para trás e para frente. Por exemplo, se fizéssemos com que o método denominado avançaretornasse um sinalizador contendo o resultado do avanço, então teríamos:





Arg.entrada arg.saída

Hom1.avança (núm-de-quadrados; avança-ok)

Objeto-alvo nome do método assinatura

mensagem

Uma mensagem para um objeto-alvo consiste em duas partes: o nome do método e aassinatura.A assinatura é uma lista de argumentos de entrada (para o objeto-alvo) ,seguidade uma lista de argumentos de saída (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 não são dados; eles sãoidentificadores de objetos. Argumentos de mensagem são, portanto, como objetos em pé.

Notação gráfica de uma mensagem - hom1.avança(num-de-quadrados;avança-ok) – do programa hominídeo sendo executada:

Contém um identificador como o 123432

núm-de-quadrados

avanço-ok

contém um identificador como o 664730

Para ilustrar esse ponto mostramos em notação gráfica uma mensagem – hom1.avança(núm-de-quadrados;avança-ok) – do programa hominídeo sendo executada.Se tivéssemos tirado um instantâneo do programa hominídeo enquanto ele estavaexecutando essa mensagem, por exemplo:

Núm-de-quadrados contém 123432

Avança-ok contém 664730


Hominídeo

avançahom1

6




O número 123432 pode ser o identificador do objeto da classe INT que normalmenteconsideramos com o inteiro 2, e 664730 pode ser o identificador do objeto da classe

BOOL que normalmente consideramos como o valor lógico true.

1.5.4 Os Papéis dos Objetos nas Mensagens

Um objeto pode ser:

• emissor de uma mensagem.• alvo de uma mensagem.• Apontado por uma variável dentro de um outro objeto.

• Apontado por um argumento passado ou retornado de uma mensagem.

Um dado objeto pode desempenhar qualquer um desses papéis em algum instantede suavida.

Um método de um objeto pode enviar mensagens para os objetos apontados pelasvariáveis privativas de objeto.

Na orientação a objeto pura, não há necessidade de dados, porque os objetos podem fazer todas as tarefas de software necessárias dos dados. E em Smaltalk que éuma linguagem pura , não há realmente dado algum! Durante o processamento, há apenasobjetos apontando para outros objetos (via variáveis) e comunicando-se com outros

objetos passando manipuladores para trás e para a frente, para outros objetos.No entanto,em C++ (que é uma linguagem mista – tanto orientada a dados e funções com orientada aobjeto), os argumentos podem ser ponteiros para qualquer coisa. Se o seu código C++ for tão puro quanto o smaltalk, então todos os seus ponteiros serão ponteiros para objetos.Mas se forem misturados objetos e dados no seu programa, então alguns dos seusargumentos poderão ser simples dados ou ponteiros para dados.

1.5.5 Tipos de Mensagem

Há três tipos de mensagem que um objeto pode receber:

Mensagem informativa: é uma mensagem para um objeto fornecendo lhe informações para que ele próprio se atualize. (É conhecida também como uma mensagem deatualização (update), para frente (forward) ou de empilhar (push)). Ela é uma mensagemorientada para o passado, pois usualmente informa ao objeto sobre o que já aconteceu emalgum lugar.

Um exemplo de uma mensagem informativa é hom1.coloca-na-grade(grade, inic-quadrado;colocação-ok). Essa mensagem informa ao objeto hominídeo qual é o quadradoinicial no qual ele foi colocado.





Mensagem interrogativa: é uma mensagem para um objeto pedindo que ele revelealguma informação sobre si próprio. (É conhecida também como uma mensagem deleitura (read), para trás (backward) ou de desempilhar (pull) ). È um método orientado

para o presente, pois solicita do objeto alguma informação atual.

Um exemplo de uma mensagem interrogativa é hom1.localização, que pede aohominídeo que nos diga em que quadrado ele está no momento. Esse tipo de mensagemnão muda coisa alguma; em vez disso, usualmente ela é uma consulta sobre a parte domundo que o objeto-alvo representa.

Mensagem imperativa: é uma mensagem para um objeto pedindo que ele faça algumaação sobre si mesmo, sobre um outro objeto ou mesmo sobre o ambiente em que seencontra o sistema . (Isso também é conhecido como mensagem de força (force) ou deação (action) ). É uma mensagem orientada ao futuro, pos pede ao objeto que execute

alguma ação em um futuro imediato.

Um exemplo de uma mensagem imperativa é hom1.avança, que faz o hominídeose mover para frente. Esse tipo de mensagem freqüentemente faz com que o objeto-alvoexecute algum algoritmo importante para saber o que fazer.

1.6 Classes

Uma classe é o estêncil (ou matriz) a partir do qual os objetos são criados(instanciados). Cada objeto tem a mesma estrutura e comportamento da classe da qual elefor instanciado.

Se o objeto ob pertence a classe C, dizemos que “ob é uma instância de C”.A distinção 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 têm a mesma estrutura, em particular,

seus métodos são idênticos, e idênticas também as variáveis. Cada objeto (instância) deuma classe tem sua própria cópia do conjunto de métodos e conjunto de variáveis que elenecessita.

As cópias do conjunto de métodos que pertencem a diversas instâncias de umaclasse são absolutamente idênticas. Como cada conjunto de métodos é puramente código

procedural, um único conjunto pode ser compartilhado por todos os objetos. Assim, em princípio cada objeto tem seu próprio conjunto de métodos, mas na prática (paraeconomizar espaço) eles compartilham a mesma cópia física.

Por outro lado, embora os identificadores e as variáveis de cadaobjeto sejam idênticos em termos de estrutura de objeto paraobjeto, eles não podem ser compartilhados entre objetos. A razão,





naturalmente, é que eles devem conter diferentes valores durante o processamento.

1.7 Herança

A herança representa outra maneira importante pela qual a orientação a objeto sedistancia das abordagens tradicionais de sistema. Ela, efetivamente, permite que seconstrua 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 novasclasses serão habilitadas a usar todos os métodos e variáveis ( métodos e variáveis de

classe e de instância) da classe original.Existem dois tipos de heranças:

• HERANÇA ÚNICA

É aquela em que cada classe tem apenas uma superclasse direta.Exemplo:

Vamos supor que temos uma classe AVIÃO em uma aplicação de aviação.AVIÃO pode ter definido em si um método de instância denominado curva e dentro deleuma variável de instância denominada curso.

A classe AVIÃO trata das atividades ou informações pertinentes a qualquer tipo

de máquina voadora. Porém, há tipos especiais de aviões que executam atividadesespeciais. Então, podemos definir uma nova classe -PLANADOR- que herdará deAVIÃO suas propriedades além de ter outro método de instância denominado

soltar_cabo e uma variável de instância denominado se_conectado.

Vamos analisar um pequeno trecho de código orientado a objeto a partir dasclasses AVIÃO e PLANADOR.

var av : AVIÃO.new;var pl : PLANADOR.new;…av.curva (novo-curso; curva-ok);

pl.soltar_cabo; pl.curva (novo-curso; curva-ok);av.soltar_cabo;…

• HERANÇA MÚLTIPLA

É aquela em que cada classe pode ter um número arbitrário de superclassesdiretas. Este tipo de herança converte a árvore de heranças com heranças únicas em um

reticulado de heranças, ela traz alguns problemas difíceis para o projeto, incluindo a possibilidade de uma superclasse herdar métodos (ou variáveis) conflitantes de seus





múltiplos ancestrais ( métodos conflitantes têm o mesmo nome e a subclasse herdeira não pode saber facilmente qual deles herdar).

Apesar de tudo , como a herança múltipla criar estruturas complexas e

incompreensíveis, você deverá usar herança múltipla com muito critério - com muito maiscritério do que com a herança única.

Exemplo:Suponhamos que queiramos criar uma classe denominada AVIÃO-DE-

PASSAGEIROS, e que tenhamos criadas outras duas classes: AVIÃO e VEÍCULOS DEPASSAGEIROS. A classe AVIÃO-DE-PASSAGEIROS poderá herdar tanto de AVIÃOcomo de VEÍCULOS-DE-PASSAGEIROS.

1.8 Polimorfismo

A palavra polimorfismo deriva de duas palavras gregas que significam,respectivamente, muitas e formas. Qualquer coisa que seja polimórfica tem,portanto a habilidade de assumir várias formas.Os livros-textos orientados a objeto têm duas definições de polimorfismo:

1. Polimorfismo é o dispositivo pelo qual o nome de um único método pode ser definidosobre mais de uma classe e pode assumir diferentes implementações em cada uma dessasclasses.

2. Polimorfismo é a propriedade pela qual uma variável pode apontar para (manter o

identificador de ) objetos de diferentes classes em instantes diferentes.Vamos supor que temos uma classe POLÍGONO, que representa o tipo de forma 2-d quea figura 1.20 exemplifica.Em POLÍGONO podemos definir um método denominado área. Esse método precisariade um algoritmo razoavelmente complexo porque ele teria de servir para qualquer um dos

polígonos de formas irregulares da Fig.1.20. Agora, vamos acrescentar mais algumasclasses - como TRIÂNGULO, RETÂNGULO E HEXÁGONO - que são subclasses de(e, portanto, herdam de) POLÍGONO.





Figura 1.20 Alguns polígonos planos.

Note que na fig.1.21 as classes TRIÂNGULO e RETÂNGULO também têm métodosdenominados área de POLÍGONO - quer dizer, calcular a área total da superfície limitada

pela forma.

Figura 1.21 Polígono e suas três subclasses.

No entanto o projetista/programador de área para RETÂNGULO escreveria o código paraseu método de uma maneira muito diferente do código de área para POLÍGONO. Por quê? Porque a área de um RETÂNGULO é simplesmente comprimento * largura; ocódigo para o método área de RETÂNGULO, consequentemente é simples e eficiente.Assim se escrevermos um código que manda a seguinte mensagem para um objetochamado de forma-duas-d:

forma-duas-d.área

podemos não saber qual o algoritmo que será usado para o cálculo da área. A razão é que podemos não saber exatamente a que classe pertence forma-duas-d. Há cinco possibilidades:

1. Forma-duas-d é uma instância de TRIÂNGULO.2. Forma-duas-d é uma instância de RETÂNGULO.3. Forma-duas-d é uma instância de HEXÁGONO.4. Forma-duas-d é uma instância de POLÍGONO.





5. Forma-duas-d é uma instância de uma classe C (por exemplo CLIENTE) que não énenhuma das quatro classes acima. Como C não tem um método denominado áreadefinido dentro dele, o envio de uma mensagem área resultará em um erro de compilação.

Você pode achar estranho que um objeto possa não ter a informação sobre a classe exatado objeto-alvo para o qual esta enviando uma mesagem. No entanto, tal situação é

bastante comum. Na linha final do código, a seguir, durante a compilação não podemossaber para que classe de objeto p apontará durante o processamento. O objeto real para oqual será apontado será determinado por uma escolha do usuário no último instante.( nocomando if).

Var p: polígonoVar t: triângulo:=triângulo.new;Var h: hexágono:=hexágono.new;

.........if usuário diz ok then p:= telse p:= hendif;.........

p.área; // aqui p pode se referir a um//triângulo ou hexágono

..........

Note que no trecho de código orientado a objeto mostrado, não precisamos de um testesobre p.área para determinar qual versão de área deverá ser executada. Este é um exemplode uma ocultação de implementação muito conveniente. Ela permite adicionar uma novasubclasse de polígono (por exemplo OCTÓGONO) sem mudar o código acima de formaalguma.

Note também a declaração var p: POLÍGONO. Esta é uma restrição de segurança sobre o polimorfísmo da variável p. Ela significa que p só pode apontar para objetos da classePOLÍGONO(ou para objetos de uma das subclasses de POLÍGONO).

O método área que originalmente foi definido em POLÍGONO, é sobreposto emTRIÂNGULO. O método de TRIÂNGULO tem o mesmo nome, mas tem um algoritmo

diferente. Ocasionalmente você pode usar a técnica da sobreposição para cancelar ummétodo definido em uma classe C por outra definição em uma das subclasses de C. Pode-se cancelar um método, redefinido-o simplesmente para retornar um erro.Relacionado ao polimorfismo esta o conceito de sobrecarga.

Sobrecarga: Ocorre quando vários métodos(ou operadores) definidos na mesma classetêm aquele nome ou símbolo. Dizemos que houve uma sobrecarga.

Tanto o polimorfismo como a sobrecarga freqüentemente requerem que o métodoespecífico a ser executado seja escolhido durante o processamento.





Conforme vimos no pequeno exemplo de código acima, a razão é que a classe exata deum objeto-alvo - e portanto, a implementação específica do método a ser executado -

pode não ser conhecida até o processamento.

A distinção entre o polimorfísmo e sobrecarga é que o polimorfísmo permite que omesmo nome de método seja definido diferentemente em classes diferentes, enquanto asobrecarga permite que o mesmo nome de método seja definido diferentemente váriasvezes na mesma classe.

1.9 Genericidade

Genericidade é a construção de uma classe C, de maneira que uma ou mais dasclasses que ela usa internamente é fornecida somente durante o tempo de execução ( édurante esse tempo que um objeto da classe C é instanciado).

Para ilustrar o conceito de genericidade, é quando pôr exemplo se deseja projetar e programar uma arvore binária ordenada e balanceada mantendo listas ordenadas declientes e produtos. Para manter estas listas ordenadas seriam necessárias duas cópias, decódigos quase idênticos.

Essa duplicação de código aumenta muito a manutenção e o tempo para revisões/alterações. Para solucionar este problema é necessário escrever a estrutura básica doalgoritmo da arvore uma só vez e então conseguir aplica-la tantas vezes quantas

quiséssemos a inteiros , clientes, produtos ou qualquer outra coisa.É ai que a genericidade se aplica, defini-se uma arvore-balanceada genérica , issosignifica que pelo menos uma das classes usada dentro de arvore-balanceada não

precisará ser atribuída até o tempo de execução . Essa seria presumivelmente a classe dositens a serem armazenados nos nós do objetos arvore balanceada particular que vamosinstanciar.

Poderíamos , 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 execução.

Depois pode-se fazer com que a arvore-cliente aponte para uma instancia daarvore balanceada que mantém em seus nos instancias da classe cliente, é como setivéssemos duplicado o código 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 genericidadegeralmente é usada em orientação a objetos para projetar essa classes contigentes. Emboraa genericidade não seja estritamente necessária para se escrever um código reutilizável

para classes contigentes, ela é certamente superior ao código duplicado ou a um projeto





frágil em que classes arbitrarias estão misturadas dentro de uma mesma estrutura declasse contigente.






Documents

Apost_PLP_Aluno