Aula 9 - Paradigmas de Linguagens de Programação

Prévia do material em texto

PARADIGMAS DE LINGUAGENS DE PROGRAMAÇÃO
Aula 09: Comandos compostos das LPs e modularização
Apresentação
Nas últimas aulas, veri�camos que as linguagens de programação (LPs) possuem diferentes formas de implementação
dos comandos necessários. Conhecemos os comandos primitivos, ou seja, aqueles que não possuem outros em seu
escopo de ação.
Nesta aula, apresentaremos os comandos compostos, destacando como as LPs os implementam graças às sequências
(ou blocos de comando) e aos comandos de decisão e de repetição. Discutiremos ainda como as LPs permitem que seus
programas sejam modularizados, destacando os tipos de modularização permitidos.
Objetivos
Registrar a implementação dos comandos sequenciais, condicionais e de repetição nas LPs;
Anunciar como as linguagens implementam a modularização.
Comando composto: sequenciais
Dando continuidade aos comandos (primitivos ou simples) anteriormente estudados, vamos agora nos ater aos
compostos ou estruturados. Trata-se dos comandos compostos por outros em seu escopo de ação.
A �gura a seguir ilustra os três comandos compostos que estudaremos:
Sequência;
Condicionais (ou de decisão);
Repetitivos (ou iterativos).
 Figura 1: Classificação dos comandos das LPs | Fonte: (WATT, 1990)
Veremos como algumas das principais LPs implementam tais comandos, destacando as suas particularidades:
A principal diretriz das linguagens imperativas – e, consequentemente, das orientadas a objeto – é que o �uxo de
execução do programa deve seguir a sequência de comandos: o comando antecedente será executado antes do
subsequente. Em geral, as LPs usam o conceito de bloco (bloco de comandos) para implementar os comandos
sequenciais.
Os blocos permitem que um conjunto de comandos seja considerado como um único. Para isso, eles agrupam comandos
primitivos e/ou compostos que podem ser executados dentro de uma repetição, de uma condição ou em um rótulo de
desvio incondicional. O próprio programa principal pode ser considerado um grande bloco.
Exemplo
Isso ocorre em C, C++, C#, Java e Pascal.
Mostraremos a seguir exemplos de implementação nas LPs do conceito de bloco de comando: de um lado, temos a
linguagem C; do outro, Pascal:
C Pascal
--------- Delimitador do bloco ---------
O bloco de comando fica entre chaves: A { abre o
bloco e } fecha o bloco.
O bloco de comando fica entre as palavras reservadas Begin, demarcando o
início dele, enquanto End o encerra.
--------- Estrutura de um bloco --------
{ bloco de comando } Begin
Bloco de comando
End
---- Exemplo de bloco de comando---
{
scanf (nota);
aux=nota;
nota=maior;
maior=aux;
printf (maior);
}
Begin
Readln (Nota);
Aux:=Nota;
Nota:=Maior;
Maior:=Aux;
Writeln (Maior);
End; 
-- O programa principal como bloco -
int main ()
{ /* início do bloco do programa */
/* Declaração de variáveis */
float altura, largura, area;
scanf (“%d”,&altura, &largura);
area = altura * largura;
print (área);
} /* fim do bloco do programa *\
Program Bloco;
Var // declaração de variáveis
Altura, Largura, Area: real;
Begin // início do bloco do programa
Readln (Altura,Largura);
Area:=Altura*Largura;
Writeln ( ,Area);
End. // fim do bloco do programa
Area :
A sintaxe e os comandos de C++ e C# são semelhantes aos de C, havendo poucas variações, como os comandos de
entrada e de saída. Em C++, usam-se os comandos cin e cout para a leitura e exibição de dados, respectivamente. Em C#,
console.read e console.readln são usados para a entrada; console.write e console.writeln, além de outras variações, para a
exibição de dados.
O próximo trecho de código possui dois blocos de comandos aninhados (um dentro do outro). O primeiro bloco contém
dois comandos de atribuição à variável num. O segundo está associado à execução de if num==0 e possui dois outros
comandos. À esquerda, nota-se o trecho de código em C; à direita, em Phyton:
C Phyton
{ num=0; 
num+=3;
if num == 0
{ num=num+5; 
 soma=0;
}
}
num=0
num=num+3
if num==0
num=num+5
soma=0
Na linguagem Phyton, a de�nição de bloco ocorre em função da endentação dos comandos, mostrando uma hierarquia
entre eles. Em Pascal e outras LPs, recomenda-se a endentação , porém isso não tem um signi�cado hierárquico.
Em geral, a endentação, implementada em muitas LPs, re�ete-se apenas visualmente. Mas Phyton é uma exceção, pois a
usa com blocos de comandos ou de sequência (de comandos).
No exemplo acima, escrito em C (lado esquerdo), observe que os comandos num=num+5 e soma=0 estão mais à direita
que if num==0. Isso ajuda na legibilidade do código, facilitando o entendimento do programa.
1
http://estacio.webaula.com.br/cursos/go0138/aula9.html
Atenção
Em C, o bloco é marcado pelas chaves { } – e não pela endentação.
Já no código em Phyton, à direita, temos a endentação com a conotação de delimitação do bloco de comandos. Neste
caso, ela tem de ser bem consciente. A maioria dos seus comandos aceita este bloco.
Exemplo
if/elif/else, for/else, while/else, def, try/except /�nally/else, class e with. Se o bloco tem apenas um comando, pode-se
escrever tudo na mesma linha: if num<0: print (´Valor Inválido´).
No trecho de código em Phyton, temos ainda um bloco com dois comandos associado ao comando if num==0:
num=num+5 e soma=0.
Já no trecho de código a seguir, temos dois blocos de comandos. O primeiro começa com o comando ind=1 e encerra
com printf(). O segundo bloco está associado ao comando de repetição e engloba outros dois: print (ind) e ind=ind+1. O
último comando printf() será executado tão logo acabe a repetição representada por while:
ind=1
while ind<=10:
print(ind)
ind=ind+1
print()
Os blocos de comandos, portanto, são implementados de diferentes formas. Já vimos três variações com as LPs para o
uso de:
Chaves: C, C++ e Java;
Begin...End: Pascal e Modula-2;
Endentação: Pthyton.
Estes blocos estão associados a outros comandos que a linguagem
permite. 
Conheceremos agora os condicionais.
Comandos condicionais (associados a uma condição)
Os comandos condicionais recebem este nome por seu cerne estar relacionado a uma condição a ser avaliada. Também
chamados de comandos de seleção ou de decisão, eles possibilitam a representação de �uxos de controle alternativos
para o programa. Uma condição é avaliada; em função do seu resultado, diferentes �uxos de controle podem ser possíveis
dependendo da LP e do tipo de comando implementado.
Em geral, as LPS implementam três tipos de comandos condicionais. Trata-se da seleção de: caminho único, caminho
duplo e caminhos múltiplos.
Comandos de repetição
Os comandos de repetição, também chamados de iterativos ou de iteração, permitem aos programadores construirem
ciclos ou laços de repetição no �uxo de controle do programa, indicando o comando ou o bloco deles que se repete até
haver a satisfação de alguma condição.
As LPs, em geral, implementam três modalidades de comandos de repetição. Eles serão agrupados em comandos com
repetições:
1
Inde�nidas
Quando não se sabe previamente o número de repetições. Dividem-se entre aqueles que:
Realizam o teste da condição da repetição no início do ciclo ou laço;
Fazem o teste da condição ao �nal do ciclo ou laço.
2
De�nidas
Quando se conhece o número de repetições.
 Figura 6: Comandos de repetição implementados nas LPs.
Comandos com repetições inde�nidas
javascript:void(0);
A maioria das LPs implementa comandos quando o número de repetições não é previamente de�nido. A quantidade de
ciclos ou lações vai depender da avaliação de uma condição, que pode ocorrer no início ou no �nal do ciclo (ou laço da
repetição).
Independente da implementação em LP, os comandos de repetição que realizam testes da condição antes do laço têm as
seguintes propriedades:
1
A sequência será executada enquanto a condição for verdadeira
Quando a condição for falsa, a sequência deixa de ser repetida. Se a condição nunca for falsa, haverá o que
denominamos loop: a sequência �ca se repetindo in�nitamente.
2
Antes de a sequência ser executada, a condição é avaliada
Portanto, ela pode não ser executada nenhumavez se a condição for falsa desde o início. Sobre os comandos
com testes no �nal do laço ou ciclo de repetição, podemos observar:
A sequência é repetida pelo menos uma vez, já que o teste da condição ocorre ao �nal do laço;
A sequência será repetida até que a condição seja verdadeira. Enquanto ela for falsa, a sequência vai sendo
repetida.
3
Caso a condição nunca seja verdadeira, a sequência entre em loop
O quadro a seguir descreve, no lado esquerdo, o �uxo de controle quando o teste do laço ocorre no início e, à
direita, quando ele acontece no �nal:
Teste no início do laço Teste no final do laço
Repete os comandos enquanto a condição é verdadeira. Sai
do laço da repetição quando a condição for falsa (false).
Repete os comandos enquanto a condição é falsa. Sai do
laço da repetição quando a condição for verdade (true).
Exemplo
Veja exemplos (em C, Pascal e Python) que elucidam os comandos de repetição com testes no início e no �nal do ciclo.
Comandos com repetições de�nidas
Quando conhecemos previamente o número de iterações, há um comando especí�co com o qual se usa uma variável para
controlar a repetição. Geralmente, trata-se do FOR.
As principais características deste comando são:
Os testes de parada são realizados antes da repetição a cada
passagem pelo laço e a cada valor da variável de controle;
O número de repetições é avaliado antes do começo da sequência a
ser repetida e deve ter valor �xo.
Mas também existem variações na implementação do FOR pelas LPs:
Tipos possíveis nas variáveis de controle;
Escopo de visibilidade desta variável;
Possibilidade de alteração desta variável e de outros elementos da
sequência que se repete;
Possibilidade de usar expressão para de�nir esta variável.
Vejamos agora algumas variações de implementação em LPs:
Linguagem Característica
Ada Variável de controle = tipo primitivo discreto (inteiro, intervalo de inteiros e tipo enumerado). Seu escopo está
restrito ao corpo da repetição. Não permite que o conteúdo da variável de controle seja alterado na sequência
que se repete. Esta variável deve assumir todos os valores do intervalo, podendo tanto ser ascendente como
descendente (a ordem de execução).
Fortran e
Pascal
Variável de controle é do tipo primitivo enumerado, em que esta variável é incrementada de uma unidade
automaticamente até que supere o valor final informado no comando (a sequência que se repete não pode alterar
o conteúdo desta variável).
javascript:void(0);
Modula-2 Determina que a variável de controle seja de um tipo primitivo e discreto. A sequência que se repete não pode
alterar esta variável.
C O comando FOR da linguagem C é o mais versátil entre as principais linguagens em uso, podendo ser usado
como um comando apropriado para a repetição indefinida. Ele contém quatro partes: 1) trecho de inicialização
da(s) variável(is) de controle executado uma vez no início; 2) trecho de teste da condição de parada executado
uma vez antes de cada laço; 3) o trecho de avanço é executado depois de cada iteração; 4) o corpo de repetição
contém os comandos que se repetem.
C++ Bem parecido com a estrutura em C, diferindo pela inclusão da definição das variáveis dentro do comando.
Exemplo
Veja exemplos da utilização do comando FOR em diferentes LPs devidamente relacionadas.
Antes disso, considere o seguinte problema: ler 10 números, calculando a soma e a média entre eles.
Saiba mais
Veja a versatilidade do comando FOR em Python.
Modularização
As técnicas de modularização buscam implementar a estratégia de dividir para conquistar a �m de apoiar a solução de
problemas complexos (ou seja, sistemas grandes). Elas buscam:
Facilitar o entendimento do programa;
Possibilitar o reuso de código.
As técnicas de modularização possibilitam dividir o sistema em módulos (partes do problema mais facilmente resolvíveis)
que agreguem (encapsulem) dados e comportamento (código). Para que um programa complexo seja dividido, usa-se a
técnica de abstração: selecionar o que de fato interessa do contexto do problema.
Em programação, chamamos este pedaço de código independente de módulo, ou seja, uma unidade que pode ser
compilada separadamente. Um módulo bem planejado possui uma �nalidade única e uma interface e�ciente com o
programa principal e os demais módulos necessários.
Conheçamos os subprogramas
A primeira forma de particionar programas grandes foi com a utilização de subprogramas que os segmentam em
módulos logicamente relacionados, mas mantêm um baixo acoplamento (baixa dependência entre eles) e uma alta
javascript:void(0);
javascript:void(0);
coesão (união de subprogramas a�ns, ou seja, coesos). No entanto, a independência deles somente foi possível com o
uso de parâmetros, diferenciando chamadas distintas de um subprograma.
Para entender melhor o uso de parâmetros, considere o
seguinte trecho de código:
Imagine que este código seja repetido em cinco locais do
programa principal. Neste caso, considere transformar o
bloco de comandos em um procedimento em linguagem
Pascal:
Em cada local onde se usa o trecho de código contido em
Procedure Troca, teríamos a chamada da rotina conforme
mostra estre trecho de código:
Temos os seguintes problemas na implementação acima:
1 O correto uso da rotina Troca obriga que todo programa que a usar declare as variáveis a, b e aux como sendo dotipo inteiro
A independência acontece com o uso de parâmetros.
Vejamos:
A chamada da procedure TROCA seria assim agora.
Observe que as variáveis do programa a,b e aux foram
trocadas para x,y e auxiliar.
A passagem de parâmetros ocorre de forma posicional: na de�nição da Procedure, de�mos os parâmetros que ela usará:
(Var a,b,aux: integer). Var indica que as três passagens de parâmetro ocorrem por referência, usada quando queremos que
as variaveis retornem ao programa principal (Program Ordena) com os seus valores alterados (pois há uma troca de
conteúdo das três variáveis).
Na chamada da rotina, temos os argumentos, ou seja, as variáveis que serão associadas, conforme sua posição, aos
respectivos parâmetros:
Troca (x,y); // chamada
Procedure TROCA (Var a,b integer); // declaração
2 O argumento (variável) x é associado ao parâmetro formal b
3 O argumento y é associado ao parâmetro formal a
Neste caso, a passagem sendo por referência (Va antes), o endereço da variável x será atribuído ao parâmetro a de forma
que qualquer referência à variável a dentro da rotina repercuta na alteração do conteúdo de x (argumento formal).
Os subprogramas são implementados de duas formas por uma LP:
Procedimentos (rotinas): Um bloco independente de código executado a partir do ponto em que ele é invocado
(chamado), retornando, ao �nal da execução, a instrução seguinte ao ponto de sua chamada;
Função: Um bloco independente de código que, após ser executado, retorna a “quem” o chamou (um valor) conforme
tipo de dado declarado.
Na linguagem Pascal, uma função é declarada assim:
Vejamos cada parte da
declaração:
Function media: Nome da
função “media”;
(nota1, nota2:real): São os
dois parâmetros formais;
: real: É o tipo de dado que a
função retorna. No caso, um
dado do tipo real.
Relembremos a de�nição da função: o unico comando é media:=
(nota1+nota2)/2. Portanto, ela retorna em media (nome da função) o
valor da função.
O uso da função média, no programa principal, seria assim:
USO1: Atribui o resultado da função a uma variável;
USO2: Exibe o resultado da função.
Programa ExemploMedia_USO1;
Var nota1, nota2, mediaaluno:real;
(* aqui entre a definição da função media
*)
begin // programa principal
 readln (nota1, nota2);
 mediaaluno:=media (nota1, nota2); //
uso da função media;
 writeln (mediaaluno);
end.
Programa ExemploMedia_USO2;
Var nota1, nota2, mediaaluno:real;
(* aqui entre a definição da função media
*)
begin // programa principal
 readln (nota1, nota2);
 writeln (media (nota1, nota2)); // uso
da função media;
end.
Na linguagem C, temos as duas formas de implementação de subprogramas: procedimentos e funções.Elas, porém,
aparecem de forma diferenciada em relação a Pascal. Da mesma forma, há diferenças no uso de parâmetros:
Em C, tudo é função;
Quando quiser implementar uma rotina, será desenvolvida uma função que retorna um valor padrão VOID (que é nada,
ou seja, simula uma função, mas apenas executa o procedimento sem retornar valor). Ele é usado no local onde seria
de�nido o tipo de dado que ela retorna;
Na passagem de parâmetros, quando o dado pode voltar alterado da funcão, passa-se, na chamada dela, o endereço
de cada variável desejada.
Vejamos o exemplo a seguir:
void naotroca (int x, int y)
{ int aux;
 aux:=x;
 x:=y;
 y:=aux;
}
void troca (int* x, int* y)
{ int aux;
 aux:= *x;
 * x:= *y;
 *y := aux’
}
main()
{ int a=10, b=20;
 naotroca (a,b);
 troca (&a,&b);
}
Façamos as seguintes observações sobre dois procedimentos:
O (retorna VOID) “naotroca” recebe os conteúdos das variáveis “a” e “b”, associando-os respectivamente aos parâmetros
“x” e “y”. Internamente, os valores de x e y são trocados de conteúdo, mas essa alteração não repercute ao retornar do
procedimento, pois a passagem por parâmetro foi por valor, ou seja, copiou-se o valor de cada argumento em cada
parâmetro;
O “troca” faz o mesmo que “naotroca”, porém a passagem de parâmetro é por referência, pois se passa o endereço (&)
das variáveis “a” e “b”, associando-o respectivamente a cada parâmetro “x” e “Y”. Quando há a troca dentro do
procedimento, ela vale no programa principal (main), pois se alterou o conteúdo de cada valor contido nos endereços
informados.
Na passagem de parâmetro por valor no momento da chamada do procedimento (função VOID) ou da função, uma cópia
do valor da variável usada como argumento é feita para a variável parâmetro.
Exemplo
Suponha que, no main(), temos naotroca (a,b) e, na declaração da função, void naotroca (int x, int y). Neste caso, na
passagem por valor, “x” (parâmetro) recebe cópia do valor de “a”; “y” (parâmetro), do conteúdo de “b”. Dentro da função void
naotroca, mesmo que o conteúdo de “x” sofra alteração, o de “a” permanece igual ao �nal de voidnaotroca. Isso vale para a
variável “b”.
Ao contrário de C++, Ada e Pascal, a linguagem C não implementa a passagem de parâmetro por referência. Por isso, ela o
endereço da variável usada como argumento de forma que a referência a ela seja feita diretamente (por intermédio de
ponteiro) em seu endereço. Assim, toda alteração realizada no parâmetro dentro de void troca repercute no valor da
variável argumento (“a” ou “b”). A chamada ao procedimento é feita usando o & (endereço) de cada variável (argumento) 🡪
troca (&a,&b):
int* x – é um ponteiro para x, que recebeu o endereço de “a”;
int* y – é um ponteiro para y, que recebeu o endereço de “b”.
Exemplo
Veja o uso de função no C. A função soma retorna um valor inteiro, e não void; por meio do comando RETURN, o valor da
função é retornado ao main() com o valor da soma entre “x” e “y” que receberam, respectivamente, os valores das variáveis
num1 e num2. No main(), o comando “resultado=soma (num1, num2);” faz com que a variável resultado receba o retorno da
função soma.
int soma (int x, int y);
{ int resultado;
resultado=x+y;
return resultado;
}
main () 
{ int num1, num2, resultado:integer;
scanf (“%d”,&num1);
scanf (“%d”,&num2);
resultado=soma (num1, num2); 
printf("Resultado = %d\n", resultado);
}
Em C++, a diferença básica para C é a existência da passagem de parâmetro por valor (ou cópia) e por referência. Em
Java, estas passagens também são implementadas por meio de objetos passados como argumento a métodos.
 Atividade
1. Sobre sequências de comando, veja estas assertivas:
I. São blocos de comando executados um após o outro.
II. Na linguagem Pascal, os blocos de comando são delimitados por chaves e, em C, por begin.. end.
III. Em Python, o bloco de comandos é identi�cado pela endentação, um deslocamento à direita, demonstrando hierarquia
entre comandos.
IV. C++ não implementa o conceito de bloco de comando.
Com base em sua análise, marque a opção que apresenta apenas as assertivas corretas.
a) I e III.
b) II apenas.
c) III apenas.
d) I, II e III.
e) I, II, III e IV.
2. Sobre comandos de decisão implementados nas LPs, avalie este trecho de código em Pascal:
Var num1, num2: integer; oper:char;
Begin
 Readln (num1,num2,oper); 
 Case oper Of
 ‘+’: result:=num1+num2;
 ‘-‘: result:=num1-num2;
 ‘*’: result:=num1*num2;
 ‘/’: result:=num1 div num2;
 end;
 writeln (result);
end.
Responda às duas perguntas: 
1. Qual a �nalidade do programa acima?
2. Escreva o mesmo código usando o comando IF.
3. Sobre os comandos de repetição, no que se refere exclusivamente às expressões compostas, avalie as assertivas a
seguir:
I. Existem dois tipos de comandos de repetição: os que repetem comandos um número �xo de vezes e os que o fazem um
número variado de vezes.
II. Os comandos de repetição para um número variável de vezes podem realizar testes no início apenas.
III. Python implementa o comando FOR de forma diferenciada das demais LPs.
IV. C e Pascal implementam comandos com número �xo e variável de vezes, sendo que, no caso do número variável de
vezes, eles oferecem um comando com teste no início e no �m do laço.
Está correto apenas o que se a�rma em:
a) I, II, III e IV
b) II e III
c) II
d) I, III e IV
e) III
4. No que concerne à implementação de procedimento e à função, bem como à passagem de parâmetros em LPs, avalie
estas assertivas:
I. Na passagem de parâmetro por referência, se o conteúdo do parâmetro for alterado dentro do procedimento ou função,
o conteúdo do argumento também será alterado...
porque
II. Na passagem de parâmetro por referência, o valor da variável usada como argumento é atribuído ao daquela usada
como parâmetro.
Analisando a relação de causa e efeito entre as assertivas I e II, responda com a opção correta:
a) As duas assertivas são verdadeiras, e a II justifica a I.
b) As duas assertivas são verdadeiras, e a II não justifica a I.
c) As duas assertivas são falsas.
d) A assertiva I é falsa; a II, verdadeira.
e) A assertiva I é verdadeira; a II, falsa.
Notas
ENDENTAÇÃO 1
Endentação é o deslocamento à direita que, em relação ao comando anterior, denota e ajuda a identi�car a hierarquia entre os
comandos.
Título modal 1
Lorem Ipsum é simplesmente uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente
uma simulação de texto da indústria tipográ�ca e de impressos. Lorem Ipsum é simplesmente uma simulação de texto da
indústria tipográ�ca e de impressos.
Referências
DEVMEDIA. FOR Python: estrutura de repetição for. 2017. Disponível em: https://www.devmedia.com.br/for-python-estrutura-
de-repeticao-for/38513. Acesso em: 4 set. 2019.
GHEZZI, C.; JAZEYERI, M. Conceitos de linguagens de programação. 2. ed. Rio de Janeiro: Campus; 1987.
SEBESTA, R. W. Conceitos de linguagem de programação. 11. ed. Porto Alegre: Bookman, 2018.
TUCKER, A. B. Programação: princípios e paradigmas. 2. ed. Porto Alegre: AMGH, 2010.
VAREJÃO, F. M. Linguagem de programação: conceitos e técnicas. Rio de Janeiro: Elsevier, 2004.
WATT, D.A. Programming languages: concepts and paradigms. New York: Prentice-Hall, 1990.
Próxima aula
Principais paradigmas de programação: características e linguagens.
Explore mais
Java: blocos e comentários de programação;
Blocos de instrução em C+ +;
Blocos de instrução em Python;
Comandos básicos de Python;
Estruturas de condição e repetição em Python;
Blocos de instrução Python na prática;
Do C/C++ para o Java: conheça as diferenças e principais características;
Delphi: estruturas de repetição.
javascript:void(0);
javascript:void(0);
javascript:void(0);
javascript:void(0);
javascript:void(0);
javascript:void(0);
javascript:void(0);
javascript:void(0);
javascript:void(0);