Linguagens Imperativas

1. Linguagens Imperativas Dupla: Ana Carolina e Danniel Araújo

2. Sumário 1- Introdução • Paradigmas de Programação 2- Paradigma Imperativo • Modelo Computacional • Arquitetura de Von Neumann • Características Centrais 3- Efeitos Colaterais 4- Exemplos Linguagens Imperativas 5- Linguagens Imperativas não Estruturadas 6- Linguagens Imperativas Estruturada

3. Introdução • Na Ciência da Computação, programação imperativa é um paradigma de programação que descreve a computação como ações, enunciados ou comandos que mudam o estado(variáveis) de um programa.

4. Paradigmas de Programação • Fornece e determina a visão que o programador possui sobre a estruturação e execução do programa. • Assim como diferentes grupos em engenharia de software propõem diferentes metodologias, diferentes linguagens de programação propõem diferentes paradigmas de programação.

5. Paradigmas de Programação • Um paradigma específico: • SmallTalk e Java- Orientações a objetos • Haskell- Funcional • Múltiplos paradigmas: • LISP, Perl, Python, C++, Oz

6. Paradigmas de programação • Os paradigmas de programação são muitas vezes diferenciados pelas técnicas de programação que proíbem ou permitem. Por exemplo, a programação estruturada não permite o uso de goto. • O relacionamento entre paradigmas de programação e linguagens de programação pode ser complexo.

7. Quanto ao paradigma • Se dividem em dois grandes grupos: • Imperativo • Declarativo

8. Paradigma Imperativo • Os paradigmas imperativos são aqueles que facilitam a computação por meio de mudanças de estado. Se dividem em: • O paradigma procedural: Fortran e o Basic. • O paradigma de estrutura de blocos: Algol 60, Pascal e C. • O paradigma de orientação a objetos: C++, Java, Python e Ruby. • O paradigma da computação distribuída: Ada.

9. Modelo Computacional • A arquitetura dos computadores exerceu um efeito crucial sobre o projeto das linguagens de programação. • Arquitetura de Von Neumann. • Se caracteriza pela possibilidade de uma máquina digital armazenar seus programas no mesmo espaço de memória que os dados, podendo assim manipular tais programas.

10. Modelo Computacional • Arquitetura de Von Neumann

11. Modelo Computacional • O modelo imperativo de programaçãobaseia-se no modo de funcionamento do computador. • O paradigma imperativo épredominante nas LPs, pois tais linguagens são mais fáceis de traduzir para uma forma adequada para execução na máquina.

12. Modelo Computacional • Linguagens imperativas são caracterizadas por três conceitos: variáveis, atribuições e sequências. • O estado de um programa imperativo é mantido em variáveis de programa que são associados com localizações de memória que correspondem a um endereço e um valor de armazenamento. • O valor da variável pode ser acessado direta e indiretamente, e pode ser alterado através de um comando de atribuição. O comando de atribuição introduz uma dependência de ordem no programa: o valor de uma variável é diferente antes e depois de um comando de atribuição.

13. Modelo Computacional • Já as funções de linguagem de programação imperativas são descritas como algoritmos que especificam como processar um intervalo de valores, a partir de um valor de domínio, com uma série de passos prescritos. • A repetição, ou laço, é usada extensivamente para processar os valores desejados. Laços são usados para varrer umasequência de localizações de memória tal como vetores, ou para acumular um valor em uma variável específica.

14. Características centrais • As características centrais das linguagens imperativas são: • as variáveis, que modelam as células de memória; • comandos de atribuição, que são baseados nas operações de transferência dos dados e instruções; • a execução sequencial de instruções; • e a forma iterativa de repetição, que é o método mais eficiente desta arquitetura.

15. Características Centrais Ex.: O valor da variável é modificado através de atribuições. Por exemplo, em Pascal: X := 5; O termo à esquerda do operador de atribuição (:=) é a variável cujo valor está sendo modificado e à direita está o novo valor. X tem valores diferentes antes e depois da atribuição. Portanto o significado (efeito) de um programa depende da ordem em que as atribuições são escritas e executadas.

16. Características Centrais • Uma última característica importante é que a repetição (laços) é utilizada extensivamente para computar valores desejados. Laços são usados para varrer um vetor ou acumular valores numa variável. • Por causa dessas características, as linguagens imperativas têm sido chamadas de orientadas a estado ou orientadas à atribuição.

17. Efeitos Colaterais • Vantagens • Eficiência (embute o modelo de Von Neumann) • Mais fácil de traduzir para a linguagem de máquina • Paradigma dominante e bem estabelecido • Modelagem “Natural” de aplicações do mundo real • Também é muito flexível • Desvantagens • Descrições demasiadamente operacionais • Focaliza o “como” e não o “quê” • Relacionamento indireto com a E/S (indução a erros/estados)

18. Exemplos de Linguagens Imperativas • Alguns exemplos de linguagens de programação que baseiam-se no modelo imperativo: • Ada • Algol • Basic • C • PHP • Java • Cobol • Fortran • Pascal • Python • Lua • Mathematica

19. Fortran • Valores e tipos: interger, real, double precision, complex, logical; • vetor: dimension<nome>(dim1, dim2, dim3), real, interger • constantes lógicas: .true., .false.

20. Fortran • Expressões: • operadores: **, *, /, +, -, .ge., .gt., .le., .lt., .eq., .ne., .not., .and., .or.

21. Fortran • Comandos e Sequências: if(<exp>)then ... end if if(<exp>) ... else if ( ) then ... else ... end if • comandos I/O: open, close, read, write,print, rewind, endfile • comandos: goto, continue, pause, stop

22. Fortran • Declarações: • declaração var.: <tipo> <id>

23. Fortran • Procedimentos e Funções: • funções: function <id> (<parâm.>) • proc.: procedure <id> (<parâm.>)

24. Pascal • Valores e tipo: boolen, interger, char, real; • estruturados: array, file,record, set

25. Pascal • Expressões: • boolean: and, or, not, xor • interger: +, -, *, div, mod, =, >=, <>. abs, sqr, trunc, round • string: var a: string; a = 'abc'; • file: type arq = file of interger;

26. Pascal • Comandos e Sequências: • comandos simples: write, writeln, read, clrscr, gotoxy, delay, readkey, upcase if-then, if-then-else case <exp> of case <op1>: case <op2>: else end for x := <inic> to|downto <fim> do while <cond> do begin ... end;

27. Pascal • Declarações: • var.: var <id>: <tipo>;

28. Pascal • Procedimentos e Funções: • procedure <id> (<parâm.>); • function <id> (<parâm.>): <tipo>;

29. C • Valores e tipos: • tipos: char, int, float, double, struct, union

30. C • Expressões: • operadores: -, +, *, /x, %, ++, >, >=, =, !=, &&, ||, !, & • bit a bit: &, |, ^, ~, >>, <<

31. C • Comandos e sequências: if(<exp.>) <comando> else <comandos> for(inic; cond; incremento) switch (<exp>){ case <op1>: ...; break; case <op2>: ...; break; default: ...; } while (<cond.>){ ...;} do ... while (<cond.>){ ...;} return <exp>, goto <tótulo>, break

32. C • Declarações: • declaração var.: <tipo><lista variáveis>; • constantes: const <tipo> <id> = <valor>;

33. C • Funções:<tipo> <id> (<parâm.>)

34. ADA • Valores e tipos: • array: <id> array(x..y) of <tipo> interger, natural, positive, character, boolean; • string: type string is array(x..y) of character; • float

35. ADA • Expressões: • operadores: =, /=, >, >=, +, -, abs, **, and, or, xor, not

36. ADA • Comandos e sequências: if <cond> then case <exp> is elsif <cont> then <alt. 1> else <alt. 2> endif; end case; when <lista escolha> => <com.> when <others> => <comandos> while <cond.> loop <comandos> end loop; for <id> in <interv> loop <comandos> end loop

37. ADA • Declarações: • var.: <id>: <tipo>;

38. ADA • Procedimentos e Funções: • procedure <id> (parâm.>) is • function <id> (<p.>) return <tipo>

39. Linguagens Imperativas Não Estruturadas • São linguagens caracterizadas pela utilização da expressão goto. • Necessária para determinar a repetição e a seleção de execução de instruções. • Uso de goto geralmente leva ao que chamam na literatura de código spaguetti.

40. Linguagens Imperativas Não Estruturadas • Exemplo de código com o uso de instrução goto, baseado na sintaxe do Pascal: read(x); 2: if x = 0 then goto 8; writeln(x); 4: read(next); if next = x then goto 4; x := next; goto 2; 8: ...;

41. Linguagens Imperativas Não Estruturadas • Fortran, Assembly e Basic são algumas das linguagens imperativas que possuem o conceito de goto.

42. Linguagens Imperativas Estruturadas • Linguagens estruturadas surgiram com o objetivo de facilitar a leitura e acompanhamento da execução de algoritmos. • Normalmente linguagens estruturadas não fazem uso de comando goto. • Instruções são agrupadas em blocos, os quais podem ser considerados como unidades de programa, abstraindo-se das suas estruturas internas.

43. Linguagens Imperativas Estruturadas • Blocos de instruções podem ser selecionados para execução através de declarações de seleção como if...else, ou repetidamente executados através de declarações de repetição como while. • Procedurais e Modulares.

44. Linguagens Imperativas Estruturadas • Exemplo de código estruturado, baseado na sintaxe do Pascal, correspondente ao mesmo exemplo da seção anterior: read(x); while x <> 0 do begin writeln(x); repeat read(next); until next <> x; x := next; end;

45. Referências • http://sistemasuniban.blogspot.com.br/2010/04/arquiterura-von-neumann-vs-harvard.html • http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_imperativa • http://www.inf.pucrs.br/~gustavo/disciplinas/pli/material/paradigmas-aula09.pdf • http://www.jairo.pro.br/lpi/ling_prog.pdf • http://pt.wikipedia.org/wiki/C%C3%B3digo_espaguete