Você está na página 1de 3

2.

PARADIGMA IMPERATIVO

A arquitetura dos computadores execeu um efeito crucial sobre o projeto das linguagens de programao. A
maioria das linguagens populares nos ltimos 35 anos foram projetadas em torno da arquitetura do computador,
conhecidas por arquitetura de von Neumann. Estas linguagens so chamadas de imperativas. Em um computador
com esta arquitetura, tanto os dados como os programas so armazenados na mesma memria, e a CPU (Unidade
Central de Processamento), que executa realmente as instrues, separada da memria. Consequentemente,
instrues e dados devem ser transportados, ou transmitidos, da memria para a CPU. Os resultados das operaes
realizadas na CPU devem ser devolvidos para a memria.

Devido a arquitetura de von Neumann, as caractersticas centrais das linguagens imperativas so: as
variveis, que modelam as clulas de memria; comandos de atribuio, que so baseados nas operaes de
transferncia dos dados e instrues; a execuo seqencial de instrues; e a forma iterativa de repetio, que o
mtodo mais eficiente desta arquitetura. Os operandos das expresses so passados da memria para a CPU, e o
resultado da expresso passado de volta para a clula de memria, representada pelo lado esquerdo do comando
de atribuio. A iterao rpida em computadores com este tipo de arquitetura porque as instrues so
armazenadas em clulas adjacentes da memria. Essa eficincia desencoraja o uso da recurso para repetio [SEB
99].

interessante comentar que algumas vezes as linguagens de programao imperativas so tambm


chamadas de procedurais, mas isto no tem relao com o conceito de procedimento. Neste captulo, ento, o
paradigma imperativo de linguagens de programao, encontrado, por exemplo, nas linguagens Fortran, Cobol,
Basic, Pascal, Modula-2, C e Ada, ser apresentado. Inicialmente, na seo 2.1, feita uma introduo ao assunto.
Na seo 2.2 caractersticas da programao imperativa, bem como exemplos de LP que utilizam este paradigma,
so descritas.

2.1. Introduo
O modelo imperativo de programao, que o mais antigo de todos, baseia-se no modo de funcionamento
do computador. Isto refletido na execuo seqencial baseada em comandos e no armazenamento de dados
altervel, conceitos que so baseados na maneira pela qual computadores executam programas a nvel de
linguagem de mquina (imperare em Latim significa comandar). O paradigma imperativo foi predominante
nas LP, pois tais linguagens so mais fceis de traduzir para uma forma adequada para execuo na mquina. Um
programa desenvolvido a partir deste modelo, por exemplo nas linguagens C e Modula-2, consiste em uma
seqncia de modificaes no armazenamento do computador [DER 90, WAT 90].

Conforme descrito anteriormente, linguagens imperativas so caracterizadas por trs conceitos: variveis,
atribuies e seqncia. O estado de um programa imperativo mantido em variveis de programa que so
associadas com localizaes de memria que correspondem a um endereo e um valor de armazenamento. O valor
da varivel pode ser acessado direta ou indiretamente, e pode ser alterado atravs de um comando de atribuio. O
comando de atribuio introduz uma dependncia de ordem no programa: o valor de uma varivel diferente antes
e depois de um comando de atribuio. Alm disso, o significado (efeito) de um programa depende da ordem na
qual os comandos so escritos e executados. J as funes de linguagens de programao imperativas so descritas
como algoritmos que especificam como processar um intervalo de valores, a partir de um valor de domnio, com
uma srie de passos prescritos. A repetio, ou lao, usada extensivamente para processar os valores desejados.
Laos so usados para varrer uma seqncia de localizaes de memria tal como vetores, ou para acumular um
valor em uma varivel especfica. Assim, devido s suas caractersticas, linguagens imperativas tem sido chamadas
de baseadas em comandos ou orientada a atribuies [GHE 97].

2.2. Programao Imperativa


Nesta seo (2.2), atravs de exemplos, so apresentadas as principais caractersticas das linguagens de
programao imperativas. As linguagens escolhidas para realizao de uma anlise comparativa so:
Fortran,
Pascal,
C,
Ada.
Em cada uma destas linguagens so abordados os seguintes tpicos:
Valores e tipo;
Expresses;
Comandos e seqncias (= estruturas de controle);
Declaraes;
Procedimentos e funes.

FORTRAN PASCAL
- valores e tipos - tipos: integer, real, double precision, - tipos: simples: boolean, integer, char,
- expresses complex, logical; vetor: dimension real; estruturados: array, file, record, set
<nome> (dim1, dim2, dim3), real, integer - expresses:
- constantes lgicas: .true., .false. boolean: and, or, not, xor
- operadores: **, *, /, +, -, .ge., .gt., .le., integer: +, -, *, div, mod, =, >=, <>. abs,
.lt., .eq., .ne., .not., .and., .or. sqr, trunc, round
string: var a: string; a = abc;
file: type arq = file of integer;
- comandos if (<exp>) then - comandos simples: write, writeln, read,
e seqncias ... clrscr, gotoxy, delay, readkey, upcase
end if if-then, if-then-else
if (<exp>) case <exp> of
... case <op1>:
else if ( ) then case <op2>:
... else
else end
... for x := <inic> to|downto <fim> do
end if while <cond> do
- comandos I/O: open, close, read, write, begin
print, rewind, endfile ...
- goto, continue, pause, stop end;
- declaraes - declarao var.: <tipo> <id> - declarao var.: var <id>: <tipo>;
- procedimentos - funes: function <id> (<parm.>) - procedimentos e funes:
e funes - proc.: procedure <id> (<p.>) procedure <id> (<parm.>);
function <id> (<parm.>): <tipo>;
verses anteriores a FORTRAN 90: no case sensitive
somente letras maisculas; outras verses
traduzem para maisculas durante a
compilao
C ADA
- valores e tipos - tipos: char, int, float, double, struct, - tipos:
- expresses union array: <id> array(x..y) of <tipo>
- operadores: -, +, *, /x, %, ++, >, >=, =, integer, natural, positive, character,
!=, &&, ||, !, & boolean, string: type string is array(x..y)
bit a bit: &, |, ^, ~, >>, << of character; float
- operadores: =, /=, >, >=, +, -, abs, **,
and, or, xor, not
- comandos if (<exp.>) <comandos> if <cond> then case <exp> is
e seqncias else <comandos> elsif <cont> then <alt. 1>
for (inic; cond; incremento) else <alt. 2>
end if; end case;
switch (<exp>){
case <op1>: ...; break; when <lista escolha> => <com.>
case <op2>: ...; break; when <others> => <comandos>
default: ...;
} while <cond.> loop
while (<cond.>){ ....;} <comandos>
do end loop;
.... for <id> in <interv> loop
while (<cond.>); <comandos>
return <exp>, goto <ttulo>, break end loop
- declaraes - declarao var.: <tipo> - declarao var.: <id>: <tipo>;
- procedimentos <lista variveis>; - procedimentos:
e funes - constantes: const <tipo> <id> = <valor>; procedure <id> (<parm>) is
- funes: <tipo> <id> (<parm>) - funes:
function <id> (<p.>) return <tipo>
case sensitive

2.3. Estudo de Caso: AWK


O material desta seo est disponvel em http://www.inf.pucrs.br/~manssour/AWK/index.html