A Linguagem de Programação do VisuAlg

A Linguagem de Programação no VisuAlg

Observação: o tipo de dado "caractere" também pode ser chamado/definido como "literal".

Operadores Aritméticos

+,-	Operadores unários, isto é, são aplicados a um único operando. São os operadores aritméticos de maior precedência. Exemplos: -3, +x. Enquanto o operador unário - inverte o sinal do seu operando, o operador + não altera o valor em nada o seu valor.
\	Operador de divisão inteira. Por exemplo, 5 \ 2 = 2. Tem a mesma precedência do operador de divisão tradicional.
+,-,*,/	Operadores aritméticos tradicionais de adição, subtração, multiplicação e divisão. Por convenção, * e / têm precedência sobre + e -. Para modificar a ordem de avaliação das operações, é necessário usar parênteses como em qualquer expressão aritmética.
MOD ou %	Operador de módulo (isto é, resto da divisão inteira). Por exemplo, 8 MOD 3 = 2. Tem a mesma precedência do operador de divisão tradicional.
^	Operador de potenciação. Por exemplo, 5 ^ 2 = 25. Tem a maior precedência entre os operadores aritméticos binários (aqueles que têm dois operandos).

Operadores de Caracteres

+	Operador de concatenação de strings (isto é, cadeias de caracteres), quando usado com dois valores (variáveis ou constantes) do tipo "caractere". Por exemplo: "Rio " + " de Janeiro" = "Rio de Janeiro".

Operadores Relacionais

=, <, >, <=, >=, <>	Respectivamente: igual, menor que, maior que, menor ou igual a, maior ou igual a, diferente de. São utilizados em expressões lógicas para se testar a relação entre dois valores do mes Veja um exemplo da estrutura Para ... faça no vídeo:
Importante: No VisuAlg, as comparações entre strings não diferenciam as letras maiúsculas das minúsculas. Assim, "ABC" é igual a "abc". Valores lógicos obedecem à seguinte ordem: FALSO < VERDADEIRO.

Operadores Lógicos

nao	Operador unário de negação. nao VERDADEIRO = FALSO, e nao FALSO = VERDADEIRO. Tem a maior precedência entre os operadores lógicos. Equivale ao NOT do Pascal.
ou	Operador que resulta VERDADEIRO quando um dos seus operandos lógicos for verdadeiro. Equivale ao OR do Pascal.
e	Operador que resulta VERDADEIRO somente se seus dois operandos lógicos forem verdadeiros. Equivale ao AND do Pascal.
xou	Operador que resulta VERDADEIRO se seus dois operandos lógicos forem diferentes, e FALSO se forem iguais. Equivale ao XOR do Pascal.

Comandos de Saída de Dados

escreva (< lista-de-expressões >)

Escreve no dispositivo de saída padrão (isto é, na área à direita da metade inferior da tela do VisuAlg) o conteúdo de cada uma das expressões que compõem < lista-de-expressões >. As expressões dentro desta lista devem estar separadas por vírgulas; depois de serem avaliadas, seus resultados são impressos na ordem indicada. É equivalente ao comando write do Pascal.

De modo semelhante a Pascal, é possível especificar o número de espaços no qual se deseja escrever um determinado valor. Por exemplo, o comando escreva(x:5) escreve o valor da variável x em 5 espaços, alinhado-o à direita. Para variáveis reais, pode-se também especificar o número de casas fracionárias que serão exibidas. Por exemplo, considerando y como uma variável real, o comando escreva(y:6:2)escreve seu valor em 6 espaços colocando 2 casas decimais.

escreval (< lista-de-expressões >).

Idem ao anterior, com a única diferença que pula uma linha em seguida. É equivalente ao writeln do Pascal.

Exemplos:

algoritmo "exemplo"
var x: real
y: inteiro
a: caractere
l: logico
inicio
x y a l escreval ("x", x:4:1, y+3:4) // Escreve: x 2.5 9
escreval (a, "ok") // Escreve: testeok (e depois pula linha)
escreval (a, " ok") // Escreve: teste ok (e depois pula linha)
escreval (a + " ok") // Escreve: teste ok (e depois pula linha)
escreva (l) // Escreve: VERDADEIRO
fimalgoritmo

Note que o VisuAlg separa expressões do tipo numérico e lógico com um espaço à esquerda, mas não as expressões do tipo caractere, para que assim possa haver a concatenação. Quando se deseja separar expressões do tipo caractere, é necessário acrescentar espaços nos locais adequados.

Comando de Entrada de Dados

leia (< lista-de-variáveis >)

Recebe valores digitados pelos usuário, atribuindo-os às variáveis cujos nomes estão em < lista-de-variáveis > (é respeitada a ordem especificada nesta lista). É análogo ao comando read do Pascal.

Veja no exemplo abaixo o resultado: algoritmo "exemplo 1" var x: inteiro; inicio leia (x) escreva (x) fimalgoritmo O comando de leitura acima irá exibir uma janela como a que se vê ao lado, com a mensagem padrão: "Entre com o valor de < nome-de-variável >"

Se você clicar em Cancelar ou teclar Esc durante a leitura de dados, o programa será imediatamente interrompido.

Veja um exemplo de algoritmos de instruções de entrada e saída nos vídeos abaixo: a) leitura de notas e calculo da média; b) efetua a leitura de três valores e armazena o resultado da soma em outra variável:

A)

B)

Comando de Desvio Condicional

se < expressão-lógica > entao
< seqüência-de-comandos >
fimse

Ao encontrar este comando, o VisuAlg analisa a < expressão-lógica >. Se o seu resultado for VERDADEIRO, todos os comandos da
< seqüência-de-comandos > (entre esta linha e a linha com fimse) são executados. Se o resultado for FALSO, estes comandos são desprezados e a execução do algoritmo continua a partir da primeira linha depois do fimse.

se < expressão-lógica > entao
< seqüência-de-comandos-1 >
senao
< seqüência-de-comandos-2 >
fimse

Nesta outra forma do comando, se o resultado da avaliação de < expressão-lógica > for VERDADEIRO, todos os comandos da
< seqüência-de-comandos-1 > (entre esta linha e a linha com senao) são executados, e a execução continua depois a partir da primeira linha depois do fimse. Se o resultado for FALSO, estes comandos são desprezados e o algoritmo continua a ser executado a partir da primeira linha depois do senao, executando todos os comandos da < seqüência-de-comandos-2 > (até a linha com fimse).

Estes comandos equivalem ao if...then e if...then...else do Pascal. Note que não há necessidade de delimitadores de bloco (como begin e end), pois as seqüências de comandos já estão delimitadas pelas palavras-chave senao e fimse. O VisuAlg permite o aninhamento desses comandos de desvio condicional.

Veja um exemplo de algoritmos de Desvio Condicional no vídeo abaixo: a)efetua a leitura de dois números e faz comparações para impressão de mensagem; b) verificar se um número informado pelo usuário é par ou impar; c) calcula e imprime uma mensagem dizendo se o aluno foi APROVADO ou REPROVADO:

A)

B)

C)

Comando de Seleção Múltipla

O VisuAlg implementa (com certas variações) o comando case do Pascal. A sintaxe é a seguinte:

escolha < expressão-de-seleção >
caso < exp11 >, < exp12 >, ..., < exp1n >
< seqüência-de-comandos-1 >
caso < exp21 >, < exp22 >, ..., < exp2n >
< seqüência-de-comandos-2 >
...
outrocaso
< seqüência-de-comandos-extra >
fimescolha

Veja o exemplo a seguir, que ilustra bem o que faz este comando:

algoritmo "Times"
var time: caractere
inicio
escreva ("Entre com o nome de um time de futebol: ")
leia (time)
escolha time
caso "Flamengo", "Fluminense", "Vasco", "Botafogo"
escreval ("É um time carioca.")
caso "São Paulo", "Palmeiras", "Santos", "Corínthians"
escreval ("É um time paulista.")
outrocaso
escreval ("É de outro estado.")
fimescolha
fimalgoritmo

Comandos de Repetição

O VisuAlg implementa as três estruturas de repetição usuais nas linguagens de programação: o laço contado para...ate...faca (similar ao for...to...do do Pascal), e os laços condicionados enquanto...faca (similar ao while...do) e repita...ate (similar ao repeat...until). A sintaxe destes comandos é explicada a seguir.

Para ... faça

Esta estrutura repete uma seqüência de comandos um determinado número de vezes.

para < variável > de < valor-inicial > ate < valor-limite > [passo < incremento >] faca
< seqüência-de-comandos >
fimpara

< variável >	É a variável contadora que controla o número de repetições do laço. Na versão atual, deve ser necessariamente uma variável do tipo inteiro, como todas as expressões deste comando.
< valor-inicial >	É uma expressão que especifica o valor de inicialização da variável contadora antes da primeira repetição do laço.
< valor-limite >	É uma expressão que especifica o valor máximo que a variável contadora pode alcançar.
< incremento >	É opcional. Quando presente, precedida pela palavra passo, é uma expressão que especifica o incremento que será acrescentado à variável contadora em cada repetição do laço. Quando esta opção não é utilizada, o valor padrão de < incremento > é 1. Vale a pena ter em conta que também é possível especificar valores negativos para < incremento >. Por outro lado, se a avaliação da expressão < incremento > resultar em valor nulo, a execução do algoritmo será interrompida, com a impressão de uma mensagem de erro.
Fimpara	Indica o fim da seqüência de comandos a serem repetidos. Cada vez que o programa chega neste ponto, é acrescentado à variável contadora o valor de < incremento >, e comparado a <valor-limite >. Se for menor ou igual (ou maior ou igual, quando < incremento > for negativo), a seqüência de comandos será executada mais uma vez; caso contrário, a execução prosseguirá a partir do primeiro comando que esteja após o fimpara.

< valor-inicial >, < valor-limite > e < incremento > são avaliados uma única vez antes da execução da primeira repetição, e não se alteram durante a execução do laço, mesmo que variáveis eventualmente presentes nessas expressões tenham seus valores alterados.

No exemplo a seguir, os números de 1 a 10 são exibidos em ordem crescente.

algoritmo "Números de 1 a 10"
var j: inteiro
inicio
para j de 1 ate 10 faca
escreva (j:3)
fimpara
fimalgoritmo

Veja um exemplo da estrutura Para ... faça no vídeo:

Importante: Se, logo no início da primeira repetição, < valor-inicial > for maior que < valor-limite > (ou menor, quando < incremento > for negativo), o laço não será executado nenhuma vez. O exemplo a seguir não imprime nada.

algoritmo "Numeros de 10 a 1 (não funciona)"
var j: inteiro
inicio
para j de 10 ate 1 faca
escreva (j:3)
fimpara
fimalgoritmo

Este outro exempo, no entanto, funcionará por causa do passo -1:

algoritmo "Numeros de 10 a 1 (este funciona)"
var j: inteiro
inicio
para j de 10 ate 1 passo -1 faca
escreva (j:3)
fimpara
fimalgoritmo

Enquanto ... faça

Esta estrutura repete uma sequência de comandos enquanto uma determinada condição (especificada através de uma expressão lógica) for satisfeita.

enquanto < expressão-lógica > faca
< seqüência-de-comandos >
fimenquanto

< expressão-lógica >	Esta expressão que é avaliada antes de cada repetição do laço. Quando seu resultado for VERDADEIRO, < seqüência-de-comandos > é executada.
fimenquanto	Indica o fim da < seqüência-de-comandos > que será repetida. Cada vez que a execução atinge este ponto, volta-se ao início do laço para que < expressão-lógica > seja avaliada novamente. Se o resultado desta avaliação for VERDADEIRO, a < seqüência-de-comandos > será executada mais uma vez; caso contrário, a execução prosseguirá a partir do primeiro comando após fimenquanto.

O mesmo exemplo anterior pode ser resolvido com esta estrutura de repetição:

algoritmo "Números de 1 a 10 (com enquanto...faca)"
var j: inteiro
inicio
j <- 1
enquanto j <= 10 faca
escreva (j:3)
j <- j + 1
fimenquanto
fimalgoritmo

Importante: Como o laço enquanto...faca testa sua condição de parada antes de executar sua seqüência de comandos, esta seqüência poderá ser executada zero ou mais vezes.

Repita ... até

Esta estrutura repete uma seqüência de comandos até que uma determinada condição (especificada através de uma expressão lógica) seja satisfeita.

repita
< seqüência-de-comandos >
ate < expressão-lógica >

Repita	Indica o início do laço.
ate < expressão-lógica >	Indica o fim da < seqüência-de-comandos > a serem repetidos. Cada vez que o programa chega neste ponto, < expressão-lógica > é avaliada: se seu resultado for FALSO, os comandos presentes entre esta linha e a linha repita são executados; caso contrário, a execução prosseguirá a partir do primeiro comando após esta linha.

Considerando ainda o mesmo exemplo:

algoritmo "Números de 1 a 10 (com repita)"
var j: inteiro
inicio
j <- 1
repita
escreva (j:3)
j <- j + 1
ate j > 10
fimalgoritmo

Importante: Como o laço repita...ate testa sua condição de parada depois de executar sua seqüência de comandos, esta seqüência poderá ser executada uma ou mais vezes.

Comando Interrompa

As três estruturas de repetição acima permitem o uso do comando interrompa, que causa uma saída imediata do laço. Embora esta técnica esteja de certa forma em desacordo com os princípios da programação estruturada, o comando interrompa foi incluído no VisuAlg por ser encontrado na literatura de introdução à programação e mesmo em linguagens como o Object Pascal (Delphi/Kylix), Clipper, VB, etc. Seu uso é exemplificado a seguir:

algoritmo "Números de 1 a 10 (com interrompa)"
var x: inteiro
inicio
x <- 0
repita
x <- x + 1
escreva (x:3)
se x = 10 entao
interrompa
fimse
ate falso
fimalgoritmo

O VisuAlg permite ainda uma forma alternativa do comando repita...ate, com a seguinte sintaxe:

algoritmo "Números de 1 a 10 (com interrompa) II"
var x: inteiro
inicio
x <- 0
repita
x <- x + 1
escreva (x:3)
se x = 10 entao
interrompa
fimse
fimrepita
fimalgoritmo

Com esta sintaxe alternativa, o uso do interrompa é obrigatório, pois é a única maneira de se sair do laço repita...fimrepita; caso contrário, este laço seria executado indeterminadamente.