Linguagem Pascal

Document Sample
Linguagem Pascal Powered By Docstoc
					Uesb – Introdução à Ciência da Computação - Linguagem Pascal




                                                                 Uesb- Universidade Estadual do Sudoeste da Bahia




                                                                    Linguagem
                                                                      Pascal

                                                               Curso:Licenciatura em Física
                                                               Disciplina: Introdução à Ciência da Computação
                                                               Semestre: 7º
                                                               Prof.Esp. Fabrício de Sousa Pinto


                                                                                     2008


  Prof.Fabrício Sousa                                                                   Página   1 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal

                                                      INDÍCE
CAPITULO I - Introdução ............................................................................... 2
                                                                                                                                CAPITULO I - Introdução
   1.1 A LINGUAGEM PASCAL ...................................................................................... 2
   1.2 COMPILADOR..................................................................................................... 2
   1.3      AMBIENTE DE DESENVOLVIMENTO ............................................................ 3                          1.1 A Linguagem Pascal
CAPITULO II – Sintaxe Básica....................................................................... 3
                                                                                                                                        A linguagem Pascal foi desenvolvida em 1968 pelo professor
   1 ALGORITMO .......................................................................................................... 3     Niklaus Wirth, na Suíça. Seu nome é em homenagem ao matemático
   2 SINTAXE DA LINGUAGEM PASCAL ......................................................................... 3                    e filosofo, Blaise Pascal, que inventou a primeira calculadora
   3 VARIÁVEIS ............................................................................................................ 4
                                                                                                                                mecânica.
   3.1 TIPOS DE VARIÁVEIS .......................................................................................... 4
      3.1.1 Variáveis Numéricas.................................................................................. 4                     A escolha da linguagem Pascal é em virtude de sua
      3.1.2 Variáveis Alfanuméricas............................................................................ 4               simplicidade, facilidade e legibilidade, tornando-a bem didática. Outra
      3.1.3 -Variáveis Lógicas..................................................................................... 5           motivação é em virtude de ser um curso técnico, será pré-requisito
   4 OPERADORES ARITMÉTICOS .................................................................................. 5                para o aprendizado da programação em Delphi® nos próximos anos.
   5 OPERADORES RELACIONAIS .................................................................................. 5                        Pascal é uma linguagem de programação estruturada.
   6- OPERADORES LÓGICOS ........................................................................................ 5
   7 EXPRESSÃO DE ATRIBUIÇÃO DE VALORES ............................................................ 5
   8 PONTO E VÍRGULA ................................................................................................ 5         1.2 Compilador
   9 INÍCIO E FIM DO PROGRAMA .................................................................................. 5
   10 COMENTÁRIOS .................................................................................................... 6
   11 COMANDO DE ENTRADA DE DADOS ..................................................................... 6                              Um computador não pode entender nem tão pouco executar
   12 COMANDO DE SAÍDA DE DADOS .......................................................................... 6                    instruções em linguagens de alto nível. Ele só entende linguagem de
   13 PRIMEIRO PROGRAMA EM PASCAL....................................................................... 6                      máquina. Desta forma, os programas em linguagens de alto nível
CAPITULO III – Estruturas ............................................................................. 7                       devem ser traduzidos antes de serem executados pelo computador.
                                                                                                                                Quem faz essa tradução são os programas tradutores: o interpretador
   1 ESTRUTURA DE DECISÃO....................................................................................... 7
                                                                                                                                e o compilador. Os dois aceitam como entrada um programa em
      1.1 Estrutura Condicional Simples.................................................................... 7
   1.2 ESTRUTURA CONDICIONAL COMPOSTA .............................................................. 8                          linguagem de alto nível (código fonte) e produzem como saída um
   2 ESTRUTURA DE REPETIÇÃO – WHILE - DO ............................................................. 8                        programa em linguagem de máquina (objeto). A diferença entre eles
      2.1 Interrupção no inicio .................................................................................... 8          está na forma de executar a tarefa de tradução. O interpretador traduz
   3 ESTRUTURA DE REPETIÇÃO – FOR-TO-DO ............................................................. 9                         para a linguagem de máquina e roda uma linha por vez, até que todo
   4 ESTRUTURA DE REPETIÇÃO – FOR-DOWNTO-DO ................................................... 9                               programa seja executado. Já o compilador traduz para a linguagem de
   5 ESTRUTURA DE REPETIÇÃO – REPEAT-UNTIL ...................................................... 10                            máquina todo o programa fonte e só então ele é executado.
   6 COMANDO CASE.................................................................................................. 10
   7 RESUMO .............................................................................................................. 11
   8 EXERCÍCIOS ......................................................................................................... 11




    Prof.Fabrício Sousa                                                                                                                                             Página    2 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal



                                                                        CAPITULO II – Sintaxe Básica
1.3 Ambiente de Desenvolvimento
                                                                        1 Algoritmo
       Pascal é uma linguagem compilada, embora um dos
compiladores mais utilizado seja o Turbo Pascal®, adotaremos o Dev-     Descrição passo-a-passo para solucionar um problema.
Pascal®, versão freeware, por causa de sua interface gráfica            Ex.: Receita de um bolo.
amigável.
       Após a digitação do código fonte, o programa deverá ser          Ex.1: Fazer um algoritmo para calcular o volume de um cubo.
compilado, caso tenha erros será exibidos, e posteriormente quando
eliminarmos todos, estará pronto para execução. Abaixo temos a             Algoritmo Volume_Cubo
janela do Dev-Pascal®                                                      Variáveis
                                                                                Altura, comprimento, largura Tipo Real;
                                                                           Inicio
                                                                              Escreva (‘Informe a altura’)
                                                                              Leia (altura)
                                                                              Escreva (‘Informe a largura’)
                                                                              Leia (largura)
                                                                              Escreva (‘Informe o comprimento’)
                                                                              Leia (comprimento)
                                                                              Volume <- altura*comprimento*largura
                                                                              Escreva (‘O volume do cubo eh:’, volume)
                                                                           Fim


                                                                           O computador não entende a linguagem natural utilizada na
                                                                        descrição dos algoritmos, utilizaremos a linguagem de alto nível
                                                                        Pascal para implementarmos os programas.

                                                                        2 Sintaxe da linguagem Pascal

                                                                        Um programa em Pascal é inicializado com a palavra reservada
       Os arquivos em Pascal possui a extensão .pas
                                                                        program seguido do nome do programa e um ponto e vírgula (;)
       Aconselhamos ao programador o uso da endentação (recuos)
sempre que possível, possibilitando uma maior legibilidade do código-
                                                                                       program nome_do_programa ;
fonte. Além disso é interesse a inserção de comentário com
informações úteis para o programador. Como sabemos não existe
melhor forma de aprendizagem do que praticando, então como                    Ex2.:   program teste;
programador implemente o máximo de programas possível e
alcancará o sucesso!
  Prof.Fabrício Sousa                                                                                     Página    3 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal

3 Variáveis

        O próximo passo é a declaração das variáveis que serão                Var
utilizados no programa.                                                         R : string[13];

        Var nome(s)_da(s)_variável(is): tipo ;                           Para declarar mais de uma variável do mesmo tipo, pode-se proceder
                                                                         das duas seguintes formas:
        Caso tenha mais de uma variável, elas devem vir separadas
por virgula (,).                                                          Var
                                                                            x, y, z : integer;
        O tipo das variáveis são os valores que podem ser atribuídos a
essas variáveis, como por exemplo, real, inteiro, etc.                   ou
        Ex.3:
                                                                         Var
       var                                                                x : integer;
              nota : real;                                                y : integer;
              codigo : integer;                                           z : integer;

        Quando declaramos uma variável estamos alocando um
espaço na memória para armazenar o valor que aquela variável
possuirá.
        No Turbo Pascal a declaração de variáveis é obrigatória no       3.1 Tipos de Variáveis
início do programa pois, caso isso não acorra, o compilador acusará
erro de compilação.
        Não é permitido o uso de acentos nos identificadores.
                                                                         3.1.1 Variáveis Numéricas
Ex.4: Declarar a variável inteira A, real B e booleana C.
                                                                         integer - Números inteiros entre -32768 e 32767.
       Var                                                               real - Números reais de 11 algarismos significativos.
          A : integer;                                                   byte - Números inteiros entre 0 e 255.
          B : real;
          C : boolean;
                                                                         3.1.2 Variáveis Alfanuméricas
        Na declaração de uma variável string, necessita-se informar a
sua máxima extensão. Esta declaração da extensão reserva uma área        string - Caracteres alfanuméricos entre apóstrofos.
fixa na memória para o processamento.                                    char - String de apenas um caractere entre apóstrofos.


Ex.5: A variável string R com 13 caracteres, seria assim declarada:


  Prof.Fabrício Sousa                                                                                        Página     4 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal



3.1.3 -Variáveis Lógicas                                       6- Operadores Lógicos
boolean - Assume apenas valores booleanos, que são:
true (verdadeiro) ou false (falso).                                                Operador      Significado
                                                                                   not           negação
                                                                                   and           e
                                                                                   or            ou
4 Operadores Aritméticos                                                           xor           ou exclusivo

                  Operador         Significado                 7 Expressão de Atribuição de Valores
                     +          Soma                                 Utilizamos o simbolo := (dois pontos igual) para atribuímos um
                     -          Subtração                      determinado valor à uma variável.
                     /          Divisão                        Ex6:
                     *          Multiplicação                           A:=B+5;
                    Div         Divisão inteira
                                                                      O símbolo := equivale a uma flecha ( <- ), no algoritmo,
                    Mod         Resto da divisão
                                                               indicando que é uma atribuição, ou seja, será armazenado na variável
                                                               A o valor de B+5.

                                                               8 Ponto e Vírgula
5 Operadores Relacionais
                                                               O ponto e vírgula no Turbo Pascal indica o fim do comando e sua
                                                               presença é obrigatória.
                Operador           Significado
                   =          Igual a
                                                               9 Início e fim do Programa
                   >          Maior que
                   <          Menor que                        Todos os programas em Turbo Pascal devem começar e terminar
                  >=          Maior ou igual a                 desse modo:
                                                               Ex.7:
                  <=          Menor ou igual a
                  <>          Diferente                           program Exemplo;
                                                                   ...
                                                                  begin
                                                                    ...
                                                                  end.


                                                               O "program" indica o início do programa;
                                                               "Exemplo" é um nome qualquer dado ao programa;
                                                               "begin" indica o início e “end" o fim do programa.

  Prof.Fabrício Sousa                                                                             Página    5 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal




10 Comentários
       Comentário é uma informação utilizada pelo programador para       12 Comando de Saída de dados
comentar partes do código fonte é que irá apenas auxilia-lo, sendo
ingnorado pelo compilador.                                               write – Imprime na tela uma determinada informação para o usuário. É
                                                                         seguido por um parênteses e a mensagem deverá vir entre aspas
       Os comentários devem ser escritos entre chaves , {....} ou        simples ( ‘ ).
parênteses com asterisco - (*....*). Não há necessidade de terminar a    writeln - Diferencia do anterior, pelo fato de mudar de linha após a
linha do comentário com ponto e vírgula.                                 exibição da informação.
Ex.8:
                                                                         Ex.11
   {Exemplo de como escrever um comentário}                                       Writeln (‘Digite a altura do cubo’) ;
   (* Pode-se escrever também desta foram *)
                                                                         OBS.: Quando usado o comando writeIn sem mensagem ou variáveis
                                                                         a serem impressas, ocorre-se apenas mudança de linha.
11 Comando de Entrada de dados
                                                                         Ex.12
read – Utilizado para leitura dos dados digitados pelo usuário. É
seguido por um parênteses e a variável deverá vir entre parênteses ( ‘        Writenln(‘’);
).
readln – Diferencia do anterior, pelo fato de mudar de linha após a      13 Primeiro programa em Pascal
leitura da informação.
                                                                                 Antes de vermos o primeiro programa em Pascal, iremos
Ex.9:                                                                    comentar sobre a função readKey(); ela será utilizada para que a
          readln(altura) ;                                               janela do Dos não feche automaticamente após a execucao do
                                                                         programa, aguardando que o usuário digite um tecla qualquer para
                                                                         fechá-la. Para usarmos essa função devemos incluir a biblioteca Uses
OBS.: Quando for necessário mais de uma entrada read ou readIn, os       Crt; no inicio do programa.
dados a serem digitados não devem ser separados por vírgulas
e sim por espaço.
Ex.10:                                                                   Ex.13- Fazer um programa para calcular o volume de um cubo.
    readln(comprimento,largura,altura);

É conveniente pedir apenas uma entrada de dado por cada comando
read ou readIn, para que não ocorra inconvenientes na entrada de
textos.

  Prof.Fabrício Sousa                                                                                      Página    6 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal


 Program Volume_Cubo;
 Uses Crt;
                                                                     CAPITULO III – Estruturas
 var
   comprimento, largura, altura, volume : real;                      1 Estrutura de Decisão
 begin
    writeln('Digite o comprimento');                                 1.1 Estrutura Condicional Simples
    readln(comprimento);
    writeln('Digite a largura');
    readln(largura);                                                     if condição
    writeln('Digite a altura');                                            then begin
    readln(altura);                                                                seqüência A de comandos
    volume:=altura*comprimento*largura;                                         end;
    writeln(’O volume do cubo eh:’, volume, ‘cm3’);
    readKey();
 end.
                                                                         onde:
                                                                         if- then – são palavras reservadas;
                                                                         condição – é uma expressão lógica.

                                                                          A seqüência A de comandos só será executada caso a
O resultado do programa acima ficaria assim no vídeo, por exemplo,       condição seja verdadeira.
caso digite-se, 4 , 5 e 3:                                                O begin e end são obrigatórios apenas, caso exista mais de
                                                                         um comando.
 O volume do cubo eh: 60 cm3                                             Ex: 14
                                                                         Program Condicional;
                                                                         Uses Crt;
                                                                         Var
                                                                           a, b, c : integer;
                                                                         if (a+b) < c
                                                                              then writeln ( ‘ A soma de A com B eh
                                                                         menor do que C’);
                                                                         Readkey();
                                                                         end.




  Prof.Fabrício Sousa                                                                                 Página    7 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal


1.2 Estrutura Condicional Composta                                      Exercício 1: Escreva um programa que leia um número menor que
                                                                        100 , e caso a informação seja digitada corretamente exiba a
 If condição                                                            mensagem: ‘ Valor digitado corretamente’, caso contrário, exiba : ‘O
   then begin                                                           valor foi digitado incorretamente’.
           Sequência A de commandos
        end                                                             Exercício 2: Fazer um programa que leia três valores inteiros ,
   else begin                                                           determine e imprima o menor deles.
           Sequência B de commandos
        end;                                                            Exercício 3 : Implemente um programa que leia os três lados de um
                                                                        triangulo é determine se o mesmo é eqüilátero, isósceles ou escaleno.


                                                                        2 Estrutura de Repetição – While - do
       Na estrutura de decisão composta em PASCAL, é necessário
tomar alguns cuidados. O comando end que precede o else do
exemplo abaixo, não deve levar ponto e vírgula. O ponto e vírgula ali   2.1 Interrupção no inicio
posicionado, indicaria que já chegou ao fim da atuação do comando if
anterior. Portanto, somente o segundo e último end deve receber o
                                                                         while condição C do
ponto e vírgula. Veja o exemplo a seguir:
                                                                         begin
Ex.15:
      Program Maior_ Dez;                                                  seqüência B de comandos.
      {Estrutura de Decisão Composta}                                    end.
      Uses Crt;
      var
          valor : real;                                                 Onde:
      begin                                                              While – do – são palavras reservadas
         writeln ( 'Digite um Valor: ');                                 Condição C – é a expressão lógica.
         readln(valor)
      if (valor > 10) then                                                     A seqüência de comandos B será repetida enquanto a
         begin                                                          condição C for verdadeira. Quando a condição for falsa,o laço não
              writeln('O valor é maior que 10');                        será mais executado e o que vier após o end será executado.
         end                                                                   Caso tenha um único comando, o begin e end podem ser
      else                                                              omitidos.
       begin
              writeln('O valor é menor do que 10');
       end;
      readKey();
      end.


  Prof.Fabrício Sousa                                                                                       Página    8 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal

                                                                         seqüência B de comandos é executada; a seguir , a variável de
                                                                         controle recebe o valor sucessor; verifica se ele ultrapassa o valor
                                                                         final ; se não ultrapassa , a seqüência B de comandos é executada ;
Ex.16:                                                                   e assim sucessivamente.


         program SomaPares;                                              Ex.17:
         Uses Crt;
         var Soma, par : integer ;                                                program SomaPares;
         begin                                                                    Uses Crt;
           soma:=0;                                                               var Soma, N : integer ;
           par:=100;                                                              begin
         while par <=200 do                                                         for N:=50 to 100 do
           begin                                                                      Soma:= Soma + 2*N;
             soma:= soma + par;                                                     writeln(‘ A soma eh: ‘, soma);
             par:= par + 2;                                                       ReadKey();
           end;                                                                   end.
         writeln(‘ A soma eh: ‘, soma);
         ReadKey();
         end.
                                                                         Exercício 4 : Fazer um programa para calcular e imprimir os valores
                                                                         numéricos de 1 a 10.


3 Estrutura de Repetição – For-to-do
                                                                         4 Estrutura de Repetição – For-downTo-do
  for variável_ de_controle := valor_inicial to valor_final do
   begin                                                                  for variável_ de_controle := valor_inicial downTo valor_final do
      seqüência B de comandos                                              begin
   end                                                                         seqüência B de comandos
                                                                            end
onde:
for- to – do – são palavras reservadas                                           A única diferença entre for-to-do e for-downTo-do é que no
variável_ de_controle – é o nome da variável                             primeiro á variável é incrementada(aumentada em uma unidade) até
valor_inicial – é o primeiro valor que a variável de controle assume.    o valor máximo, enquanto que no segundo a variável é decrementada
valor_final - é o valor máximo que a variável de controle pode           (diminuída em uma unidade), até atingir o valor mínimo.
assumir.

        Nessa estrutura a variável de controle recebe o valor inicial;
verificada se ela ultrapassa o valor final; se não ultrapassa, a

  Prof.Fabrício Sousa                                                                                       Página    9 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal

                                                                            Ex.19:

Ex.18:                                                                      program SomaPares;
                                                                            Uses Crt;
         program SomaPares;                                                 var Soma, Par : integer ;
         Uses Crt;                                                          begin
         Var                                                                Soma:=0;
          Soma, N : integer ;                                               Par:=100;
         begin                                                              repeat
         Soma:=0;                                                               Soma:= Soma + Par;
           for N:=100 downTo 50 do                                              Par:= Par + 2;
             Soma:= Soma + 2*N;                                             Until Par > 200;
           writeln(‘ A soma eh: ‘, soma);                                     writeln(‘ A soma eh: ‘, soma);
         ReadKey();                                                         ReadKey();
         end.                                                               end.



5 Estrutura de Repetição – repeat-until                               Exercício 5 : Implemente um programa que só termina quando for
                                                                      digitado um número negativo.
         repeat
           seqüência A de comandos
         until condição                                               6 Comando Case

Onde:                                                                        O comando case é extremamente importante para
                                                                      estruturação de um programa que possua diversas opções de
 Repeat-until – são palavras reservadas                               execução, tomando-o bem legível e estruturado, evitando o uso
 Condição – é a expressão lógica.                                     repetido do if.
                                                                             Para a execução de um determinado comando CASE,
       Nessa estrutura, a seqüência A de comandos será repetida até   somente uma dessas seções será selecionada. A seleção está
enquanto a condição for verdadeira. Quando for falsa, a repetição é   baseada numa série de testes de comparação, sendo todos
interrompida, e a seqüência de comandos, que vier logo após a         executados sobre um valor desejado. A estrutura CASE também é
estrutura, passa a ser executada.                                     chamada de seleção múltipla.




  Prof.Fabrício Sousa                                                                                  Página    10 de 11
Uesb – Introdução à Ciência da Computação - Linguagem Pascal




          CASE valor OF                                        Exercício 6: Escreva um programa em que o usuário digite o número
            Opcao1: comando 1;                                 do mês e exiba o mês corresponde por extenso. Caso seja um
            Opcao2: comando 2;                                 número inválido informar ao usuário.
             ...
            OpcaoN: comando N;
          ELSE                                                 7 Resumo
            Comandos;                                                  Os três tipos de comandos de controle de repetição devem ser
          END;                                                 utilizados visando às seguintes características:

                                                               - Comando for:
                                                               Utiliza-se no caso de saber o número de repetições antecipadamente
                                                               e o passo de incremento ou decremento for sempre 1. Não se deve
                                                               alterar o valor da variável de controle.
Ex.20:                                                         - Comando repeat:
                                                               Controla a condição de repetição após sua execução. Este comando é
                                                               sempre executado pelo menos uma vez.
 Program Prog06;
 Uses Crt;                                                     - Comando while:
 var                                                           Controla a condição de repetição antes da sua execução. Pode
  valor : integer;                                             ocorrer situações em que o comando while não seja executado.
 begin
    write('Digite um no. inteiro        entre 1 e 4');
 readln(valor);                                                8 Exercícios
 case valor of
 2 : begin
        writeln('Número Digitado        = Dois');                 Exercício 7: Implementar um programa em Pascal que leia
     end;                                                         quatros notas de uma determinada disciplina e calcule sua média.
 3 : begin                                                        Exercício 8: Fazer um programa para calcular a área de um
        writeln('Número Digitado        = Três');                 triângulo.
     end;
 4 : begin                                                        Exercício 9: Fazer um programa que leia três números e calcule
        writeln('Número Digitado        = Quatro');               a soma do quadrado desses números.
     end;                                                         Exercício 10: Implementar um programa que leia números
 end; {case}                                                      inteiros e retorne o maior deles.
 ReadKey();                                                       Exercício 11: Fazer um programa que faça a conversão de graus
 end.                                                             Fahrenheit para centígrados ( C=5/9 (F-32) )




  Prof.Fabrício Sousa                                                                            Página    11 de 11