LINGUAGEM E TÉCNICAS DE

PROGRAMAÇÃO
Estruturas fundamentais de algoritmos
 Estruturas Fundamentais: Sequência, Decisão e
Repetição
• Os algoritmos usam apenas instruções primitivas de atribuição, de entrada e saída de
dados.
• Qualquer conjunto de dados, fornecido a um algoritmo destes, será submetido ao mesmo
conjunto de instruções, executadas sempre na mesma sequência.
• No entanto, muitas vezes é preciso executar diversas ações em função dos dados
fornecidos ao algoritmo, dependendo do conjunto de dados de entrada do algoritmo, deve-
se executar um conjunto diferente de instruções.
• É necessário controlar o fluxo de execução das instruções em função dos dados fornecidos
como entrada.
 Estruturas Fundamentais
• estruturas sequenciais;
• estruturas de decisão;
• estruturas de repetição.

Fonte: Pixabay, 2022 (disponível em Codificação Programação - Foto gratuita no Pixabay)

 Estrutura Sequencial
• Na estrutura sequencial, os comandos de um algoritmo são executados numa sequência
preestabelecida.
• Cada comando é executado somente após a finalização do comando anterior.
• A estrutura sequencial é caracterizada por um único fluxo de execução em fluxogramas.
• Em português estruturado, a estrutura sequencial é composta por um conjunto de
comandos dispostos ordenadamente.
Estrutura Sequencial
 Estrutura de Decisão
• Nas estruturas de decisão, o fluxo de instruções a ser seguido é escolhido em função do
resultado da avaliação de uma ou mais condições. Uma condição é uma expressão lógica.
• Há dois tipos de estruturas de decisão, a saber:
– Estruturas de Decisão do Tipo Se (simples, composta, encadeada)

– Estruturas de Decisão do Tipo Faça Caso

 Estruturas de Decisão do Tipo Se (simples,
composta, encadeada)
• Neste tipo de estrutura, uma única expressão lógica é avaliada.
• Se o resultado for verdadeiro (V), então um certo conjunto de instruções será executado,
mas se o resultado da avaliação for falso (F), uma instrução diferente será executada.
• Uma construção do tipo Se em fluxogramas pode ser vista como uma bifurcação, em que
há dois caminhos que podem ser seguidos. A execução do algoritmo seguirá
necessariamente por um deles. A escolha é feita em função do resultado da expressão:
– um dos caminhos será seguido se a condição for verdadeira;

– e o outro será seguido se a condição for falsa.

Estruturas de Decisão do Tipo Se (simples,
composta, encadeada)
 Estruturas de Decisão do Tipo Se (simples,
composta, encadeada)
• A sintaxe da estrutura de decisão do tipo Se em português estruturado
 Estruturas de Decisão do Tipo Se (simples,
composta, encadeada)
• Note que apareceram novas palavras, que são Se, então, Senão e Fim_se.

• A semântica desta construção é a seguinte: a condição é avaliada, se o resultado

for verdadeiro, então o comando composto1 é executado. Ao final de sua execução,
o fluxo do algoritmo segue pela próxima instrução, ou seja, o primeiro comando
após o Fim_se. Se a condição for avaliada como falsa, o comando composto2 será
executado e, após seu término, o fluxo do algoritmo segue pela próxima instrução
após o Fim_se.
 Estruturas de Decisão do Tipo Se (simples,
composta, encadeada)
• Note o uso da construção Se-Então-Senão-Fim_se, para determinar se um aluno
foi aprovado ou reprovado de acordo com a sua média.
 Estruturas de Decisão do Tipo Se (simples,
composta, encadeada)
• Existem casos em que o comando composto2 não é utilizado, resumindo a sintaxe
da construção à forma abaixo indicada.
 Estruturas de Decisão do Tipo Faça Caso
• Neste tipo de estrutura, pode haver uma ou mais condições a serem testadas e um
comando composto diferente associado a cada uma delas.

• A sintaxe da construção Faça Caso está abaixo indicada, em fluxograma e em

português estruturado, respectivamente.
Estruturas de Decisão do Tipo Faça Caso
 Estruturas de Decisão do Tipo Faça Caso
• O funcionamento do Faça Caso é o seguinte: ao entrar-se numa construção do tipo
caso, a condição 1 é testada, se for verdadeira, o comando composto1 é
executado e, após o seu término, o fluxo de execução prossegue pela primeira
instrução após o Fim_caso. Se a condição 1 for falsa, a condição 2 é testada e se
for verdadeira, o comando composto2 é executado, e, após o seu término, o fluxo
de execução prossegue pela primeira instrução após o Fim_caso, e assim por
diante.
 Estruturas de Repetição
• É muito comum a situação em que se precisa repetir certo trecho de um programa
determinado número de vezes. Por exemplo, quando é preciso calcular a folha de
pagamento de uma empresa, sendo que o mesmo cálculo é efetuado para cada
um dos funcionários.

• Essas estruturas de repetição são muitas vezes chamadas de Laços ou de Loops.

 Estruturas de Repetição
• A classificação das estruturas de repetição é feita de acordo com o conhecimento
ou não do número de vezes que os comandos serão executados. Então, os laços
dividem-se em:
– laços contados: quando se sabe quantas vezes o comando composto deverá ser executado.

– laços condicionais: quando não se sabe o número de vezes que o conjunto de comandos no
interior do laço será repetido.
 Laços Contados
• Os laços contados são bastante utilizados quando se conhece o número de vezes
que se deseja executar um certo conjunto de comandos. Esse tipo de laço é uma
estrutura dotada de mecanismos para contar o número de vezes que o comando
composto em seu interior é executado.
• Abaixo temos a sintaxe para os laços contados em português estruturado:
 Laços Contados
• A semântica do laço contado é a seguinte: no início da execução da construção é
atribuído um valor a variável <var>.
• Se <var> for maior que o <número final>, então o comando composto não é
executado e a execução do programa segue pelo primeiro comando seguinte a
Próximo.
• Se <var> for menor que o <número final>, então o comando composto é executado
e, ao final do mesmo, o valor de <var> é incrementado de 1, 2,..., n de acordo com
o valor em <inc>.
• Feito isso, é novamente feita a comparação entre <var> e <número final> e repete-
se o processo até que <var> tenha um valor maior que <número final>.
• Quando o laço é finalizado, a execução do algoritmo prossegue pela instrução
imediatamente seguinte ao Próximo.
 Laços Contados
• É importante saber que:
– <var> é uma variável, pois seu valor é alterado a cada iteração (volta do laço);

– <número final> e <inc> podem ser constantes ou variáveis.

– <inc> é o valor adicionado à variável <var> ao final de cada iteração do laço. Algumas linguagens
de programação permitem atribuir um valor negativo, de modo que o valor da variável <var>
diminui a cada iteração.
Como exemplo de uso do laço contado, tem-se um algoritmo para somar 30 vezes o mesmo número
 Laços Contados
• Já que o incremento da variável contador é de 1 na construção Para, então este
trecho passo 1 poderia ser omitido.
• Mais um exemplo de uso do laço contado, tem-se um algoritmo para realizar o
decremento de 15 números (de 20 até 5) e efetuar a subtração do número 5 destes
números.
 Laços Condicionais
• Laços condicionais são aqueles em que o conjunto de comandos em seu interior é
executado enquanto uma determinada condição seja satisfeita. Nos laços
condicionais, não se sabe quantas vezes o interior do laço será executado.

• A construção que implementa o laço condicional em português estruturado é o faça

enquanto e sua sintaxe é a seguinte:
 Laços Condicionais
• Sua semântica é a seguinte: ao início da construção Faça enquanto a condição é
testada, se o seu resultado for falso, então o comando composto no seu interior
não é executado e a execução segue normalmente pela instrução seguinte ao
fim_enquanto.

• Se a condição for verdadeira o comando composto é executado e, ao seu término,

retorna-se ao teste da condição. Então, o processo continua enquanto a condição
testada for verdadeira.
 Laços Condicionais
• Abaixo, tem-se o fluxograma representando a construção do Faça_enquanto.
 Aplicações
• As aplicações nas estruturas de repetição, importantes em qualquer linguagem de
programação, são:
• Contador;
• Acumulador;
• Flag.
 Contador
• É uma variável numérica qualquer, a qual recebe um valor inicial, e que é
incrementada por um valor fixo, normalmente +1, a cada repetição.

• Abaixo temos um exemplo, em que a variável x é um contador que conta de 1 até

20.
 Contador
• Nos dois exemplos de laços contados, usando o para/Proximo também foi utilizada
esta técnica de contador. A variável que é o contador, nestes dois exemplos, foi
chamada de contador, mas poderia ter outro nome como x, y ou z.

• Note que a variável que é contador não precisa ser incrementada ou decrementada,
o próprio comando para/Proximo realiza o incremento ou decremento.
 Acumulador
• É uma variável numérica qualquer, que recebe um valor inicial, e que é
incrementada por um valor variável, a cada repetição.

• Como exemplo, vamos calcular a média aritmética das notas de uma turma de 40
alunos, imprimindo primeiro as notas e sua soma, e depois a média.
 Acumulador
• Outro exemplo: Fazer um algoritmo para ler os salários de 500 funcionários de uma
determinada empresa e contar quantos ganham menos de 5 salários mínimos e
quantos ganham mais de 15 salários mínimos. Somar o total da folha de
pagamento do mês.
 Flag
• Flag é um dado falso, usado quando não se sabe o número total de determinada
variável. Serve para condição de fim.

• Por exemplo, para calcular a média de idades de uma turma de alunos, e não se
sabe quantos alunos. Na lista de idades, vamos acrescentar a idade falsa (flag) de
99 anos.
 Aninhamentos
• Um aninhamento é o fato de se ter qualquer um dos tipos de construção
apresentados nesta unidade, dentro do conjunto de comandos de uma outra
construção.

• Em qualquer tipo de aninhamento é preciso que a construção interna esteja

completamente embutida na construção externa.
 Síntese
• As estruturas de controle do fluxo de execução são essenciais para que se possa
alterar a sequência de execução dos comandos de um programa em função dos
dados do mesmo.

• Um comando composto é um conjunto de comandos simples, sejam eles

instruções primitivas ou instruções como as estudadas nesta unidade.

• Uma estrutura sequencial é aquela em que os comandos vão sendo executados

numa sequência preestabelecida, um após o outro.
 Síntese
• As estruturas de decisão permitem escolher qual o caminho a ser seguido num
algoritmo em função de uma ou mais condições. A instrução Se usa apenas uma
condição, enquanto que a instrução Faça caso usa uma ou mais condições.
• As estruturas de repetição são utilizadas quando se quer repetir um trecho de um
algoritmo. Quando o número de vezes que o trecho será repetido é conhecido diz-
se que o laço é do tipo contado (a construção usada é o Para). Quando este
número não é conhecido e é função de certa condição, então temos os laços
condicionais (a construção usada é o Faça enquanto).
 Síntese
• Nas estruturas de repetição, temos três aplicações, a saber: contador, acumulador
e flag.

• Os aninhamentos podem usar qualquer uma das construções apresentadas, desde

que a construção mais interna deva estar inteiramente contida na construção mais
externa.