Post on 13-Apr-2017
Rafael Martins – rafael84@gmail.com
Instituto Superior de Tecnologia em Ciência da Computação
Petrópolis, Outubro de 2007
O Algoritmo Organização das idéias em passos:
Bem estruturados
Concisos
Coerentes com o resultado esperado
Disciplina base para o estudo das linguagens de programação
Possibilita avaliar os pormenores do programa a ser desenvolvido
O Algoritmo Construído e validado através de lápis e papel:
Estimula o raciocínio, porém torna o aprendizado
mais difícil.
Impossibilita a visualização dos resultados de
algoritmos complexos.
Construído e executado no computador:
Facilita e agiliza o aprendizado.
Algoritmos e Programas
Programação: codificação de um algoritmo, segundo uma linguagem de programação específica
Formas de representar um algoritmo:
Fluxogramas
Linguagens naturais
Pseudo-linguagens
Algoritmos e Programas Fluxograma:
É um tipo de diagrama
Representa um processo
Permite visualizar os caminhos (fluxos) e as etapas de processamento
Mais intuitivo que uma descrição textual
Linguagem natural:
Linguagem convencional, escrita e/ou falada
Algoritmos e ProgramasPseudo-linguagem:
Linguagem textual
Pseudocódigo:
Uma das formas mais utilizadas atualmente
Instruções descritas de forma imperativa
Sintaxe semelhante à do Português
Conceitos Linguagem de máquina:
Linguagem que os computadores podem compreender
Linguagem de baixo nível:
Utiliza números binários, hexadecimais, alguns símbolos e letras
Próxima da linguagem de máquina
Linguagens de alto nível:
Utilizam notações matemáticas e grupos de palavras
Próxima da linguagem natural
Conceitos
Código fonte: programa escrito em linguagem de programação
Código objeto: programa escrito em linguagem de máquina
Tradutor: transforma o código fonte em código objeto
Ligador (Linker): programa ou módulo que faz a ligação entre o
programa e as bibliotecas relacionadas
Conceitos
Programação estruturada:
Simples
Amplamente utilizada
Segmentação da solução em sub-rotinas
Linguagem de Máquina
Totalmente expressa em forma binária (0s e 1s)
É a única linguagem diretamente reconhecida pelo
computador
Exige grande conhecimento dos dispositivos de
máquina
Linguagem de Máquina
Extremamente trabalhosa
Difícil aprendizado
Pouco expressiva para a maioria das pessoas
Linguagens de Programação
Criadas para tornar a programação mais acessível
Utilizadas para a codificação de algoritmos
Indispensáveis para o desenvolvimento de software comercial
Tradução e Execução de Programas
Estratégias dos tradutores
Compilação
Interpretação
Híbrida
A Solução LIA LIA – Linguagem Interpretada de Algoritmos:
Ferramenta que objetiva facilitar o aprendizado do processo de construção de algoritmos e programas de computador
Aperfeiçoamento de programadores experientes
O pacote LIA:
Linguagem
Interpretador
Ambiente de Desenvolvimento Integrado (ADI)
Manual
Exemplos
Backus-Naur Form
Definições Modelo para a representação de gramáticas
Proposto por John Backus e aprimorado por Peter Naur
Baseia-se em regras de produção
Utilizado para expressar gramáticas livres de contexto
EBNF
NotaçõesNotação Representação Descrição
Produções ::= Separa o lado esquerdo do lado direito de uma produção
Terminais “terminal” Texto delimitado por aspas
Não-terminais <não-terminal> Texto delimitado pelos símbolos < e >
Operadores | Operador lógico “OU”
[...] Opcional
{...} Opcional com repetição (zero ou mais)
{...}+ Repetição (uma ou mais)
(...|...|...) Escolha múltipla
Exemplo de gramática em EBNF<programa> ::= “begin” <comandos> “end”
<comandos> ::= <comando> {";" <comando>}
<comando> ::= <ident> "=" <expressão>
<ident> ::= <letra> {<letra> | <digito>}
<letra> ::= A | B | C | ... |Z
<digito> ::= 0 | 1 | 2 | ... | 9
<expressão> ::= <termo> [ (+|-) <expressão> ]
<termo> ::= <fator> [ (*|/) <termo> ]
<fator> ::= <identificador>
| "(" <expressão> ")"
Histórico, hierarquia, projeto e construção
Início Os primeiros compiladores:
Datam em torno do ano 1950
Consumiam muito tempo de desenvolvimento
FORTRAN (FORmula TRANslator):
Primeira linguagem de alto nível
Desenvolvida entre 1954 e 1957
Hierarquia das Linguagens
Fases de um compilador
Análise
Análise Léxica
Análise Sintática
Análise Semântica
Síntese
Geração e Otimização de código
Interpretação de código
Fases de um compilador
Fase de Análise
Definição Realizada a análise do código fonte:
Caracteres Lexemas
Lexemas Tokens
Geralmente implementada como uma função ou classe:
Código fonte só é lido uma vez
Exemplo Como exemplo, a análise léxica da instrução de atribuição:
Horas <- Minutos / 60;
Agrupa os caracteres nos seguinte tokens: Identificador Horas
Símbolo de atribuição
Identificador Minutos
Símbolo de divisão
Número 60
Fase de Análise
Definição
Agrupa tokens em frases gramaticais
A frase gramatical é uma regra da sintaxe da linguagem
Funções
Assegurar que a sintaxe da linguagem é atendida
Reunir os tokens em estruturas básicas para geração de instruções
Fase de Análise
Conceitos
A especificação da sintaxe:
Apenas define os padrões de formação das instruções
Não determina o significado coletivo de cada construção
Exemplo: “Fulano comeu cinco litros de roupa.”
Definição
Processo de validação das estruturas sintáticas no contexto geral do programa fonte
Regras semânticas não possuem um modelo representação amplamente difundido
Funções
Análise de escopo
Múltiplas declarações de uma mesma variável
Compatibilidade entre tipos
Coerência entre declaração e uso de identificadores
Correlação entre parâmetros formais e atuais
Técnicas utilizadas
Resumo
Implementação sem o auxilio de ferramentas de apoio
Programação Orientada a Objetos (POO)
Etapas de compilação e interpretação estão em uma DLL
Funções ativadas por uma interface gráfica
Diagrama – O Interpretador LIA
Regras em EBNF e algoritmos exemplo
Elementos BásicosNúm. Regras
1 <id> ::= "_" | <letra> { "_" | <letra> | <digito> }
2 <letra> ::= "a" | "b" | ... | "z" | "A" | "B" | ... | "Z"
3 <digito> ::= "0" | "1" | ... | "9"
4 <num_int> ::= { <digito> }+
5 <num_real> ::= <num_int> "." <num_int>
6 <caracteres> ::= """ { <caractere ASCII> } """
7 <const> ::=<num_int> | <num_real> | "verdadeiro" | "falso" |<caracteres>
8 <tipo> ::= "inteiro" | "real" | "caractere" | "logico"
ExpressõesNúm. Regras
9 <expressao> ::= <log_rel>
10 <log_rel> ::=<soma_sub> [ ("="|">"|">="|"<"|"<="|"<>"|"e"|"ou") <soma_sub>]
11 <soma_sub> ::= <mult_div> [ ("+"|"-") <mult_div> ]
12 <mult_div> ::= <unario> [ ("*"|"/"|"mod"|"div") <unario> ]
13 <unario> ::= [ ("nao"|"+"|"-") ] <parenteses>
14 <parenteses> ::="(" <log_rel> ")" | <id> [<elem_vet>|<params_atuais>] |<const>
15 <elem_vet> ::= "[" <expressoes> "]"
16 <expressoes> ::= <expressao> ["," <expressao>]
17 <params_atuais> ::= "(" <expressoes> ")"
Declarações
Núm. Regra
18 <decs> ::=
[ { <vars_dec>
| <consts_dec>
| <func_dec>
| <proc_dec> } ]
Algoritmo decs;
Procedimento SubRotina;
Constantes
A = 1; B = 2; C = 3;
Constante
N = “XYZ”;
Procedimento Aninhado;
Variavel AA: real;
Inicio
AA <- A + B + C;
Fim;
Inicio { SubRotina}
Aninhado;
Fim;
Inicio { decs }
SubRotina;
Fim.
Declaração de VariáveisNúm. Regras
19 <vars_dec> ::="variavel" <var_dec> ";"
| "variaveis" { <var_dec> }+ ";"
20 <var_dec> ::= <id> {"," <id>} ":" [<vet_def>] <tipo> ";"
21 <vet_def> ::= ( "matriz" | "vetor" ) "[" <faixas> "]" "de"
22 <faixas> ::= { <faixa> }+
23 <faixa> ::= <num_int> ":" <num_int>
algoritmo MultiDeclaracoes;
variaveis nota1,nota2,media: real; nome: caractere;
inicio
escreva("Digite o seu nome: ", nome); leia(nome);
escreva("Entre com Nota 1: "); leia(nota1);
escreva("Entre com Nota 2: "); leia(nota2);
media <- (nota1 + nota2) / 2;
escrevaln("Aluno: ", nome, " - Média: ", media);
fim.
Declaração de ConstantesNúm. Regras
24 <consts_dec> ::= "constante" <const_dec> ";” | "constantes" { <const_dec> }+ ";"
25 <const_dec> ::= <id> "=" <expressao> ";"
algoritmo MultiDeclaracoes2;
constantes APROVADO = 7.0; RECUPERACAO = 4.0;
variaveis nota1,nota2,media: real; nome: caractere;
inicio
escreva("Digite o seu nome: ", nome); leia(nome);
escreva("Entre com Nota 1: "); leia(nota1);
escreva("Entre com Nota 2: "); leia(nota2);
media <- (nota1 + nota2) / 2;
se media >= APROVADO entao
escrevaln("Aluno: ", nome, " aprovado.");
senao
se media >= RECUPERACAO então
escrevaln("Aluno: ", nome, " em recuperação.");
senao
escrevaln("Aluno: ", nome, " reprovado.");
fim_se;
fim_se;
fim.
Declaração de FunçõesNúm. Regras
26 <func_dec> ::=
"funcao" [<param_formais>] ":" <tipo> ";"
<decs>
"inicio"
<cmds>
"fim" ";"27 <param_formais> ::= "(" {<param_formal>}+ ")"28 <param_formal> ::= ["ref"] <id> {"," <id>} ":" <tipo> ";"
algoritmo testeFunc;
funcao PI: real;
inicio
retorno <- 3.14159;
fim;
variavel C, r: real;
inicio
r <- 3;
C <- 2 * PI * r;
escrevaln(C);
fim.
Declaração de ProcedimentosNúm. Regras
29 <proc_dec> ::= "procedimento" <params_formais> ";"
<decs>
"inicio"
<cmds>
"fim" ";"
algoritmo testeProc;
procedimento Imprimir(nome,valor: caractere);
inicio
escrevaln(nome, “: ”, valor);
fim;
inicio
Imprimir(“LIA”, “Linguagem Interpretada de Algoritmos”);
fim.
ComandosNúm. Regras
30 <cmds> ::= { <cmd> ";" }31 <cmd> ::= <cmd_atrib>
| <cmd_se>
| <cmd_para>
| <cmd_enq>
| <cmd_rep>
| <cmd_esc>
| <cmd_escreva>
| <cmd_escrevaln>
| <cmd_leia>
| <sub_rot>
Comando de AtribuiçãoNúm. Regra
32 <cmd_atrib> ::= <id> [<elem_vet>] "<-" <expressao>
algoritmo Atribuicoes;
variaveis
i: inteiro;
r: real;
l: logico;
c: caractere;
inicio
r <- 3.14159;
r <- r * r;
escrevaLn(r);
l <- verdadeiro ou falso;
escrevaLn(l);
l <- 2 > 1;
escrevaLn(l);
c <- "Como é fácil fazer uma atribuição de valor!";
escrevaLn(c);
fim.
Comando SeNúm. Regra
33 <cmd_se> ::= "se" <expressao> "entao"
<cmds>
["senao" <cmds>]
"fim_se"
algoritmo teste_condicional;
inicio
se 2 > 1 entao
escrevaln("Esta instrução será escrita na tela.");
escrevaln("E esta também.");
senão
escrevaln("Já esta será ignorada.");
fim_se;
fim.
Comando ParaNúm. Regras
34 <cmd_para> ::= "para" <id> "de" <expressao> "ate" <expressao> "faca"
<cmds>
"fim_para"
algoritmo instrucao_para_10;
variavel
i: inteiro;
inicio
para i de 1 ate 10 faca
escrevaln("Valor de i é: ", i);
fim_para;
fim.
Comando EnquantoNúm. Regra
35 <cmd_enq> ::= "enquanto" <expressao> "faca"
<cmds>
"fim_enquanto"
algoritmo testeValor;
variavel
val: inteiro;
inicio
escreva("Digite 9 para sair: ");
leia(val);
enquanto val <> 9 faca
escreva("Digite 9 para sair: ");
leia(val);
fim_enquanto;
fim.
Comando RepitaNúm. Regra
36 <cmd_rep> ::= "repita"
<cmds>
"ate" <expressao>
algoritmo testeValor;
variavel
val: inteiro;
inicio
repita
escreva("Digite 9 para sair: ");
leia(val);
ate val = 9;
fim.
Comando EscolhaNúm. Regras
37 <cmd_esc> ::= "escolha" <expressao>
<casos>
["senao" <cmds>]
"fim_escolha"38 <casos> ::= {<caso>}+
39 <caso> ::= "caso" <expressoes> ":" <cmds> "fim_caso" ";"
algoritmo Calculadora;
variaveis
op1,op2: inteiro;
operacao: caractere;
inicio
escreva("Operando 1: "); leia(op1);
escreva("Operando 2: "); leia(op2);
escreva("Operacao: "); leia(operacao);
escolha operacao
caso "+","somar": escreva(op1 + op2); fim_caso;
caso "-","subtrair": escreva(op1 - op2); fim_caso;
caso "*","multiplicar": escreva(op1 * op2); fim_caso;
caso "/","dividir": escreva(op1 / op2); fim_caso;
fim_escolha;
fim.
Comando Escreva / EscrevaLnNúm. Regras
40 <cmd_escreva> ::= "escreva" [ "(" <expressões> ")" ]41 <cmd_escrevaln> ::= "escrevaln" [ "(" <expressões> ")" ]
algoritmo Tabuada;
variaveis
t: inteiro;
i: inteiro;
v: vetor[1:10] de inteiro;
inicio
para t de 1 ate 10 faca
escrevaln ("-------------");
escrevaln ("Tabuada de ", t);
escrevaln ("-------------");
para i de 1 ate 10 faca
v[i] <- i * t;
escrevaln(t, " x ", i , " = ", v[i]);
fim_para;
escrevaln;
fim_para;
fim.
Comando LeiaNúm. Regra
42 <cmd_leia> ::= "leia" "(" <var> { "," <var> } ")"43 <var> ::= <id> [<elem_vet>]
algoritmo teste_leia;
variaveis
n1,n2: inteiro;
soma: inteiro;
inicio
escrevaln("Calculo de Soma");
escrevaln;
escreva("Entre com o primeiro número: ");
leia(n1);
escreva("Entre com o segundo número: ");
leia(n2);
soma <- n1 + n2;
escreva("Resultado: ", soma);
fim.
Chamadas à sub-rotinasNúm. Regra
17 <params_atuais> ::= "(“ <expressoes> ")"44 <sub_rot> ::= <id> [<param_atuais>]
Algoritmo rotinas;
Procedimento A;
Inicio
Fim;
Procedimento B(i: inteiro);
Inicio
Fim;
Inicio
A;
B(1);
Fim.
AlgoritmoNúm. Regras
45 <algoritmo> ::= "algoritmo" <id> ";"
<decs>
"inicio"
<cmds>
"fim" "."
Para a Linguagem LIA
Definições
Tipos especiais de variáveis
Capacidade para armazenar mais um valor ao mesmo tempo
Para a linguagem LIA, vetor é sinônimo de matriz
Multidimensionais
Possuem um tipo e um nome pré-definidos
Acesso aos elementos
Através do índice do elemento entre COLCHETES, logo após o nome do vetor:
Nome do vetor [ índice do elemento ]
No modelo acima, índice do elemento é qualquer expressão cujo valor seja um número inteiro.
Exemplosnotas[1] <- 6.5;
notas[2] <- 7.5;
media <- notas[1] + notas[2];
dias[1+2] <- "Terça-feira";
alunos[1] <- "Ana";
alunos[2] <- "Beto";
reprovados[1] <- 2;
escrevaLn("Aluno reprovado: ", alunos[ reprovados[1] ]);
Declaração
VARIAVEL nome: VETOR [ dimensão1, dimensão2, ... , dimensãoN ] : TIPO;
VARIAVEIS nomes: VETOR [ dimensão1, dimensão2, ... , dimensãoN ] : TIPO;
VARIAVEL nome: MATRIZ [ dimensão1, dimensão2,... , dimensãoN ] : TIPO ;
VARIAVEIS nomes: MATRIZ [ dimensão1, dimensão2,... , dimensãoN ] : TIPO;
Dimensões
Limite Inferior : Limite Superior
Exemploalgoritmo Media;
variaveis
notas: vetor[1:3] de real;
soma, media: real;
inicio
notas[1] <- 5.5;
notas[2] <- 6.0;
notas[3] <- 8.0;
soma <- notas[1] + notas[2] + notas[3];
media <- soma / 3;
escreva(media);
fim.
Ambiente de Desenvolvimento Integrado
Apresentação Interface gráfica para facilitar a manipulação de algoritmos
na linguagem LIA
Principais funcionalidades
Editor de textos com suporte à coloração do código fonte;
Execução passo a passo (instrução a instrução) de algoritmos;
Inspeção de símbolos do algoritmo em estrutura de árvore;
Funcionalidades
Exportação de entradas e saídas de dados para arquivo
Controle de ativação de sub-rotinas representada em estrutura de pilha numerada
Especificação de pontos de parada em instruções
Funcionalidades
Possibilidade de manter vários arquivos abertos simultaneamente
Histórico dos últimos arquivos abertos
Manual integrado da linguagem LIA
Tela Principal
Manipulando algoritmos LIA Manipulando diversos arquivos simultaneamente
Módulo de Entrada e Saída Meio pelo qual as rotinas de entrada e saída de dados coletam e
exibem dados ao usuário.
Assemelha-se a uma janela de comandos tipo DOS, normalmente chamada de console.
Registra histórico de leituras e escritas realizadas pelo algoritmo
Na leitura de valor o nome da variável é exibido na barra horizontal azul
Módulo de Entrada e Saída
Módulo Inspetor de Símbolos Instrumento de depuração
Permite visualizar automaticamente o conteúdo de cada variável modificada ao longo do processo de execução do algoritmo
Monitora Variáveis simples
Vetores/matrizes
Constantes
Dados organizados em estrutura de árvore, por escopo
Módulo Inspetor de Símbolos
Módulo Pilha de Ativação
Registra as ativações de sub-rotinas em uma lista numerada e organizada em forma de pilha
Exibe o nome e os valores dos parâmetros
Módulo Pilha de Ativação
Utilizando o ADI para a linguagem LIA
Funcionalidades do Depurador Execução passo a passo
Pausar e abortar a execução
Acompanhar todo o processo de execução, instrução a instrução
Visualizar o conteúdo das variáveis
Observar a pilha de ativação das sub-rotinas
Inspecionar a entrada e a saída de dados
Tratamento de Erros
Apresenta mensagens que auxiliam a correção
Sempre que possível, o cursor do teclado é movido para a coluna e a linha onde está o erro
Modos de ExecuçãoFuncionalidade ou Característica Padrão Rápido
Abortar execução Sim SimExecução passo a passo Sim NãoInspeção de símbolos Sim NãoPilha de ativação Sim Não
Eficiência – Velocidade de execução Não Sim
Baixa utilização de memória e processador Não Sim
Possibilidade de salvar o histórico de E/S Sim Sim
Pontos de parada Sim Não
Conclusão O propósito do autor/desenvolvedor é disseminar a
solução LIA que foi construída:
Linguagem
Interpretador
Ambiente de Desenvolvimento Integrado
Sempre que possível, funcionalidades e eventuais correções serão incluídas em novas versões