Baixe Linguagem Pascal - Apostilas - Informática Part1 e outras Notas de estudo em PDF para Informática, somente na Docsity!
LINGUAGEM PASCAL
ÍNDICE
- I – Introdução pág
- I.1 – A linguagem Pascal
- I.2 – Por que Turbo Pascal
- I.3 – Equipamento necessário
- II – Um programa em Pascal
- II.1 – O primeiro programa
- II.2 – Estrutura de um programa simples
- III – Noções Básicas preliminares
- III.1 – Elementos básicos do Turbo Pascal
- III.1.1 – Caracteres utilizados
- III.1.2 – Palavras reservadas
- III.1.3 – Identificadores pré-definidos
- III.1.4 – Regras para formação de identificadores
- III.1.5 – Comentários
- III.1.6 – Números
- III.1.7 – Strings
- III.2 – Definição de variáveis
- III.2.1 – Tipos de dados pré-definidos
- III.2.2 – A declaração Var
- III.3 – Constantes
- III.3.1 – A declaração const
- III.3.2 – Constantes pré-definidas
- III.3. 3 – Constantes tipadas (inicialização)
- III.4 Operadores
- III.4.1 – Operadores aritméticos
- III.4.2 – Concatenação de strings
- IV.1 – Write e Writeln IV – Entrada e saída de dados
- IV.2 – Read e Readln
- IV.3 – ReadKey
- IV.4 – Impressora
- IV.5 – Funções e procedures para controle de vídeo
- IV.5.1 – ClrScr
- IV.5.2 – Gotoxy(x,y)
- IV.5.3 – ClrEol
- IV.5.4 – Delline
- IV.5.5 – InsLine
- V – Comandos para controle do fluxo do programa
- V.1 – Operadores relacionais
- V.2 – Operadores lógicos
- V.3 – If Then Else
- V.4 – Case
- V.5 – For
- V.6 – Repeat Until
- V.7 – While Do
- V.9 – Uso do while e repeat para controle de digitação de tela
- V.8 – Labels e Goto
- VI – Procedures - VI.1 – Estrutura de um programa com procedimentos - VI.2 – Declaração de procedures - VI.3 – Passagem de parâmetros - VI.4 – A declaração forward - VI.5 – O escopo de objetos num programa
- VII – Functions - VII.1 – Declaração de funções - VII.2 – Recursividade
- VIII – Tipos de dados estruturados - VIII.1 – A declaração Type - VIII.2 – Array - VIII.2.1 – Arrays unidimensionais - VIII.2.2 – Conversão de números binários - VIII.2.3 – Arrays Multidimensionais
- IX – Outros tipos de dados estruturados - IX.1 – Record - IX.1.1 – Definição de records - IX.1.2 – Acesso aos elementos da estrutura - IX.1.3 – Declaração with - IX.2 – Tipo Set - IX.2.1 – Operações em tipos Set - IX.2.2 – Operadores relacionais
- X – Exercícios e uso do turbo pascal - X.1 – Exercícios: uso de comandos seqüenciais - X.2 – Exercícios: uso de if e case - X.3 – Exercícios: uso de for , while e repeat - X.4 – Exercícios: uso de functions e procedures - X.5 – Exercícios: uso de arrays e strings
- X.6 – Comandos e atalhos para uso do Turbo Pascal e debug - X.6.1. Procedimentos para executar o Pascal - X.6.2 Procedimentos para efetuar Debug
traduzidos antes de serem executados pelo computador. Quem faz essa tradução são os programas tradutores. Existem basicamente 2 tipos de programa tradutor: o interpretador e o compilador. Os dois aceitam como entrada um programa em linguagem de alto nível (fonte) e produzem como saída um programa em linguagem de máquina (objeto). A diferença entre eles está na forma de executar a tarefa de tradução. O interpretador traduz para a linguagem de máquina e roda uma linha por vez, até que todo programa seja executado. Já o compilador traduz para a linguagem de máquina todo o programa fonte e só então ele é executado. Existem linguagens de programaçäo interpretadas e compiladas. O Cobol é compilado, o Basic pode ser tanto compilado como interpretado e assim por diante. A linguagem Pascal é tradicionalmente compilada. O processo de compilação deve seguir as seguintes etapas: Edição: utilizar um editor de textos para escrever e gravar nosso programa fonte. Compilação: utilizar um compilador para traduzir o programa fonte para um programa em linguagem de máquina. LinkEdição: finalmente, devemos juntar ao programa compilado as diversas rotinas necessárias que, normalmente, ficam armazenadas numa biblioteca. Após todo esse processo, suponha que você chegue à conclusão de que o programa tenha que sofrer modificações. Você terá que repetir os três passos descritos, e assim sucessivamente até que o programa fique ao seu gosto. O compilador Turbo Pascal facilita todo esse processo, pois integra um editor de textos, um compilador e um linkeditor. A compilação pode ser feita tanto em disco como em memória, o que faz com que seja bem rápida. Além disso, o Turbo Pascal atende aos padrões da linguagem Pascal definidos por Niklaus Wirth, "o pai da linguagem". Na realidade, o Turbo Pascal vai além, pois possui inúmeras procedures e funções a mais do que as existentes no padrão da linguagem Pascal.
I.3 - Equipamento necessário
Os exemplos e programas contidos neste curso foram escritos num PC 486DX 50 com dois drives de disquete, um winchester de 340 megabytes, um monitor monocromático e 640 Kbytes de memória RAM. No entanto, a configuração mínima poderia ser um IBM/PC-XT com um winchester de 40M.
II - UM PROGRAMA EM PASCAL
II.1 - O primeiro programa
Aqueles que nunca tiveram a oportunidade de fazer um programa em Pascal devem estar curiosos para saber como deve ser o seu aspecto. Por isso, antes de prosseguir com os meandros da linguagem Pascal, mostrarei um pequeno programa devidamente comentado.
PROGRAMA EXEMPLO.PAS -> Pequeno exemplo de um programa em Pascal. Tem a finalidade única e exclusiva de mostrar os diversos componentes de um programa em Pascal. {Tudo que estiver entre chaves são comentários e não são levados em conta pelo compilador.}
Program Exemplo1; { este e o cabeçalho do programa }
USES Crt; { Aqui estou utilizando uma UNIT chamada CRT; existem várias, e inclusive você pode criar as suas. Nestas units temos procedures e functions previamente compiladas. }
{ área de definição dos dados que serão usados no programa } Const Meu_Nome = 'Thelmo'; { nesta área podemos definir todas as constantes que quisermos utilizar no programa } Var idade :integer; altura :real; nome :string[30]; sexo :char; { todas as variáveis que forem utilizadas no corpo do programa deverão ser declaradas na subárea Var }
{ área das instruções do programa } Begin ClrScr; { apaga a tela } For i:=1 to 80 do Write('-'); { escreve uma linha tracejada na tela } Writeln('Meu nome e -------> ',Meu_Nome); For i:=1 to 80 do Write('-'); Write('Qual o seu nome ----> '); Readln(Nome); For i:=1 to 80 do Write('-'); Write('Qual a sua idade ---> '); Readln(idade); For i:=1 to 80 do Write('-'); Writeln('nossas idades somam --> ', 34+idade); For i:=1 to 80 do Write('-'); Write('Prazer em conhece-lo'); End.
II.2 - Estrutura de um programa simples em Pascal
Todo programa em Pascal é subdividido em 3 áreas:
- cabeçalho do programa,
- área de declarações,
- corpo do programa. Na definição padrão da linguagem Pascal, o cabeçalho do programa é obrigatório, no entanto, no Turbo Pascal ele é opcional. A área de declarações é subdividida em seis sub-áreas, a saber:
- Label
- Const
- Type
- Var
- Procedures
- Functions As subáreas Label, Type, Procedures e Functions serão estudadas mais à frente. Darei agora, uma breve explicação das outras subáreas, pois mais para frente estudaremos cada uma delas com profundidade. Todas as constantes que formos utilizar no nosso programa, podem, se assim desejarmos, ser definidas na subárea Const.
III.1.3 - Identificadores pré-definidos
O Turbo Pascal possui inúmeros identificadores pré-definidos, que não fazem parte da definição padrão da linguagem Pascal. Esses identificadores consistem em Procedures e Functions, que podem ser utilizados normalmente na construção de programas. Exemplos: ClrScr : limpa a tela de vídeo DelLine : deleta a linha em que está o cursor e assim por diante. Constantemente, novas procedures e functions são criadas pela Borland (criadora do Turbo Pascal), aumentando desta forma o número de identificadores. São UNITS que tornam o Turbo Pascal mais poderoso do que ele já é.
III.1.4 - Regras para formação de identificadores
O usuário também pode definir seus próprios identificadores, na verdade nós somos obrigados a isso. Nomes de variáveis, de labels, de procedures, functions, constantes etc. são identificadores que devem ser criados pelo programador. Mas para isso existem determinadas regras que devem ser seguidas: 1-) O primeiro caractere do identificador deverá ser obrigatoriamente uma letra ou um underscore (_). 2-) Os demais caracteres podem ser letras, dígitos ou underscores. 3-) Um identificador pode ter no máximo 127 caracteres. 4-) Como já dissemos anteriormente, não pode serusada uma palavra reservada do Pascal.
Exemplos de identificadores válidos: Meu_Nome MEU_NOME igual ao anterior __Linha Exemplo
Exemplos de identificadores não válidos: 2teste : começa com número Exemplo 23 : tem um espaço
III.1.5 - Comentários
Comentários são textos que introduzimos no meio do programa fonte com a intenção de torná-lo mais claro. É uma boa prática em programaçäo inserir comentários no meio dos nossos programas. No Turbo Pascal, tudo que estiver entre os símbolos (* e *) ou { e } será considerado como comentário.
III.1.6 - Números
No Turbo Pascal, podemos trabalhar com números inteiros e reais. Os números inteiros podem ser representados na forma hexadecimal, basta precedê-los do símbolo $. Os números reais também podem ser representados na forma exponencial. Isto varia de versão para versão do turbo Pascal. A seguir estão as faixas de valores válidas para a versão 7.0:
TIPO FAIXA FORMATO Shorting -128..127 Signed 8-bit
Integer - 32768..32767 Signed 16-bit Longint - 2147483648.. 2147483647 Signed 32-bit Byte 0..255 Unsigned 8-bit Word 0..65535 Unsigned 16-bit
TIPO FAIXA DÍGITOS BYTES
real 2.9e-39..1.7e38 11-12 6 single 1.5e-45..3.4e38 7- 8 4 double 5.0e-324..1.7e308 15-16 8 extended 3.4e-4932..1.1e4932 19-20 10 comp -9.2e18..9.2e18 19-20 8
III.1.7 - Strings
Strings são conjuntos de caracteres entre aspas simples. Exemplos: 'isto é uma string' '123456' etc.
III.2 - Definição de variáveis
As variáveis que forem utilizadas no corpo do programa, devem ser declaradas numa subárea específica chamada Var. Para estudar essa subárea devemos primeiro ver os tipos de variáveis pré- definidos em Turbo Pascal.
III.2.1 - Tipos de dados pré-definidos
Os tipos de dados pré-definidos em Turbo Pascal são divididos em duas categorias: Escalares Simples: Char, Boolean, todos os tipos de inteiros citados acima e todos os tipos de reais citados acima, Escalares estruturados: String, Array, Record, File, Set, e Text. Inicialmente, iremos estudar os escalares simples e o tipo String pela sua utilização prática inicial. Os demais tipos estruturados serão vistos mais para a frente.
char: O tipo char corresponde a todos os caracteres que podem ser gerados pelo teclado: dígitos, letras e símbolos tais como & , # , ***** etc. Os caracteres devem vir entre aspas simples: ‘A’, ‘Z’, ‘1’, ‘%’.
boolean: O tipo boolean só pode assumir os valores FALSE e TRUE.
string : Este tipo é chamado de estruturado ou composto pois é constituído a partir de um tipo simples que é o char. O tipo string é composto por um conjunto de caracteres entre aspas simples: ‘Jose’, ‘meu primeiro programa!’.
shortint - integer - longint - byte - word : Ver tabela acima (III.1.6).
real - single - double - extended - comp : Ver tabela acima (III.1.6).
III.2.2 - A declaração Var
III.3 - Constantes
III.3.1 - A declaração const
Nesta subárea, podemos definir tantas constantes quantas quisermos. Sintaxe:
Const Meu_nome = 'Thelmo'; cor_preferida = 'verde'; número_máximo = 24345; (* e assim por diante *)
Toda vez que nos referirmos às constantes acima, o Turbo Pascal substituí-las-á pelos seus respectivos valores.
III.3.2 - Constantes pré-definidas
Existem algumas constantes pré-definidas que podemos utilizar sem ter que declará-las, por exemplo: PI = 3.1415926536E + 00 FALSE TRUE NIL Pointer nulo, veremos mais adiante. MAXINT = 32767
III.3.3 - Constantes tipadas ou inicialização de variáveis
A declaração de variáveis na subárea Var apenas reserva espaço de memória para elas, mas não as inicializa, ou seja, até que se atribuam valores a elas, seus valores serão desconhecidos. Quando necessitarmos declarar a variável e dar seu valor inicial, podemos usar uma constante tipada, cuja sintaxe é:
Const variável : tipo = valor; Exemplos: const Contador : integer = 100; c : char = 'A'; Estamos definindo duas variáveis: contador, que é inteira e vale inicialmente 100 , e c, que é do tipo char e cujo valor inicial é 'A'.
III.4 Operadores
III.4.1 - Operadores aritméticos
+ adição / divisão entre números reais
- subtração DIV divisão entre números inteiros ***** multiplicação MOD resto da divisão
III.4.2 – Concatenação de strings
Esta operação é representada pelo sinal de adição, ou seja, +. Os operandos devem ser do tipo string ou char. Exemplos:
'Isto é uma ' + 'string' = 'Isto é uma string' NomeCompleto := Nome + ‘ ‘ + Sobrenome;
PROGRAMA EXEMPLO : Mostra como utilizar operadores aritméticos Program Operadores_aritimeticos; Uses CRT; Var x,y,z : integer; r1,r2 : real; Begin ClrScr; (* limpa a tela *) x:=10; y:=20; z:=x+y; writeln(z); (* escreve o valor de z na tela de vídeo *) x:= 20 DIV 3; y:= 20 MOD 3; writeln(x); (* escreve 6 na tela *) writeln(y); (* escreve 2 na tela *) r1:=3.24; r2:=r1/2.3; writeln(r2); end.
IV - ENTRADA E SAÍDA DE DADOS
IV.1 - Write e Writeln
Estas são as principais procedures destinadas a exibir dados no vídeo. A diferença entre write e writeln reside no fato de que a procedure write escreve o parâmetro e mantém o cursor do lado daquilo que foi escrito, enquanto que writeln passa o cursor para a próxima linha. Estas procedures possuem 3 formas de sintaxe, a saber:
Primeira forma: Write(parâmetro_1,Parâmetro_2, ...);
Program Escrever1; Uses CRT; Var i : integer; r : real; c : char; s : string[20]; Begin ClrScr; (* apaga a tela e coloca o cursor em 1,1 *) Writeln('Exemplos de aplicação de writeln e write'); writeln; (* apenas pula uma linha *) i:=100; r:=3.14; c:='A'; s:='interessante';
IV.2 - Read e Readln
São utilizadas para ler dados digitados. A procedure Read lê um dado do teclado até se pressionar ENTER; cada tecla digitada é ecoada para o vídeo; após pressionar ENTER, o cursor permanece no mesmo lugar. Readln faz a mesma coisa, só que o cursor passa para a próxima linha. A sintaxe geral para estas procedures é:
Read (Var_1,Var_2,Var_3,...);
Program Ler1; Uses CRT; Var a,b,c:integer; Begin clrscr; readln(a,b,c); writeln (a,' ',b,' ',c); end.
Program Ler2; Uses CRT; Var i : integer; r : real; c : char; s : string[10]; Begin ClrScr; Write('Digite um numero inteiro ------> '); Readln(i); Write('Digite um numero real ---------> '); Readln(r); Write('Digite um caractere -----------> '); Readln(c); Write('Digite uma string -------------> '); Readln(s); Writeln;Writeln ; (* pula duas linhas *) Writeln(i); Writeln(r); Writeln(c); Writeln(s); ReadKey; End.
Program AreaTriang; { calcula área de triângulos } Uses CRT; Var Base, altura: Real; (* base e altura do triângulo *) Begin ClrScr; Writeln('CALCULO DA ÁREA DE TRIANGULOS':55); Writeln; Write('Valor da base ------> '); Readln(base);
Writeln; Write('Valor da altura ----> '); Readln(altura); Writeln; Writeln; Writeln('Área do triângulo = ',base*altura/2 : 10 : 2); ReadKey; End.
IV.3 ReadKey : Lê uma tecla digitada sem que seja necessário pressionar a tecla ENTER
Program Ler3; Uses CRT; Var tecla: char; Begin Write('digite uma tecla ->'); Tecla:=readkey; Writeln; writeln('você digitou ',tecla); end.
IV.4 - Impressora
Podemos enviar dados para a impressora através das procedures Write e Writeln. Para tanto, devemos colocar, antes dos parâmetros a serem enviados à impressora, o nome lógico LST. Exemplo: Writeln('isto vai para o vídeo'); Writeln(lst,'isto vai para a impressora',' e isto também');
IV.5 - Funções e procedures para controle de vídeo
IV.5.1 – ClrScr: Limpa a tela e coloca o cursor na primeira coluna da primeira linha. A tela de vídeo é dividida em 80 colunas e 25 linhas.
IV.5.2 - Gotoxy(x,y): Move o cursor para a coluna x e linha y. O canto superior esquerdo tem coordenadas (1,1) e o inferior direito (80,25).
Program Video1; Uses CRT; Var x,y : Byte; Begin ClrScr; Gotoxy(10,2); Write('Coluna 10 da linha 2'); x:=40; y:=10; Gotoxy(x,y); Write('Coluna 40 da linha 10'); ReadKey; End.
IV.5.3 – ClrEol: Limpa desde a posição atual do cursor até o final da linha.
Os comandos de decisão (If, Case, While, Repeat...) a seguir permitem colocar uma condição e fazer o programa desviar, seguindo ora por um, ora por outro caminho. As condições podem ser formadas com operadores relacionais e lógicos.
V.1 - Operadores relacionais
O Turbo Pascal possui ao todo 7 operadores relacionais para a tomada de decisões: = igual <> diferente > maior que < menor que >= maior ou igual que <= menor ou igual que IN testa se um elemento existe em um conjunto
1-) Se A=30 e B=50 então ( A = B ) FALSE ( A < B ) TRUE
2-) Se A=TRUE e B=FALSE ( A <> B ) TRUE ( A = B ) FALSE
3-) Se A=50 , B=35, C='A' , D='B' ( ( A < B ) OR ( C < D ) ) TRUE Neste exemplo, a avaliação será verdadeira se uma ou outra expressão for verdadeira; como C < D, então a resposta é TRUE.
V.2 - Operadores lógicos
As expressões formadas com os operadores relacionais, utilizadas em comandos If e outros comandos de decisão, podem ser combinadas com os operadores lógicos and , or e xor, formando expressões complexas. Expressões que se tornarem muito complexas devem ser organizadas usando-se parênteses.
AND e OR ou XOR ou exclusivo
A operação AND resulta em TRUE se e somente se todos os operandos forem TRUE; se um deles ou mais de um for FALSE então o resultado será FALSE. A operação OR resulta TRUE quando pelo menos um dos operandos for TRUE. A operação XOR resulta TRUE quando os operandos forem diferentes entre si, isto é, quando um for TRUE o outro deverá ser FALSE.
Program operadLogic; Uses CRT; Var x,y : boolean; Begin x:=TRUE; y:=FALSE; Writeln( x OR y ); (* escreve TRUE *)
Writeln( x AND y ); (* escreve FALSE *) Writeln( x XOR y ); (* escreve TRUE *) ReadKey; End.
V.3 - If Then Else: O comando If permite ao programa tomar decisões. Ele pode ter duas sintaxes:
Primeira sintaxe : If <expressão_lógica> Then Comando;
Expressão_lógica pode ser simples ou até relações complexas. Se a expressão_lógica resultar verdadeira (TRUE), então o comando será executado, caso contrário, não. Para os casos em que tivermos mais de um comando para ser executado, eles deverão vir delimitados pelas palavras Begin e End.
If <expressão_lógica> Then Begin Comando_1; Comando_2; Comando_3;
... End;
No caso anterior, se expressão_lógica for TRUE, todos os comandos entre as palavras Begin e End serão executados, caso contrário, nenhum deles. Observe que os comandos 1, 2 e 3 estão deslocados para a direita: isto facilita visualizar que eles dependem da condição then do if para serem executados (caso contrário, não serão). Esta endentação é importante para a clareza do programa.
Segunda sintaxe: If <expressão_lógica> Then Comando_ Else Comando_2;
Neste caso, se expressão_lógica for TRUE então comando_1 será executado e comando_2 não; caso contrário, comando_2 será executado e comando_1 não. Repare que não temos ; (ponto e vírgula) no final de comando_1: antes do else não colocamos o ponto e vírgula.
Podemos também escrever, usando begin .. end:
if <expressão> then begin comando_1; comando_2;
... end (* não tem ; *) else begin comando_3; comando_4; ... end;
Program UsoIf1; { testa número digitado }
then writeln(x,' ',y,' ',z) else writeln(x,' ',z,' ',y) else writeln(z,' ',x,' ',y) else if (y>=z) then if (x>=z) then writeln(y,' ',x,' ',z) else writeln(y,' ',z,' ',x) else writeln(z,' ',y,' ',x); ReadKey; end.
O bloco dos Ifs aninhados também pode ser escrito usando begin .. end. Observe a endentação: importante para a clareza do programa. Assim:
if (x>=y) then begin if (x>=z) then begin if (y>=z) then writeln(x,' ',y,' ',z) else writeln(x,' ',z,' ',y); end else writeln(z,' ',x,' ',y); end { antes do else: não tem ; } else begin if (y>=z) then begin if (x>=z) then writeln(y,' ',x,' ',z) else writeln(y,' ',z,' ',x); end else writeln(z,' ',y,' ',x); end;
Program UsoIf4; { Determina se os numeros x y z digitados são lados de um triângulo: 1-) Se x<y+z e y<x+z e z<x+y então x,y,z são lados de um triângulo e se: 2-) x=y=z então é um triângulo Equilátero 3-) x=y ou x=z ou y=z então é um triângulo Isósceles 4-) x<>y<>z então é escaleno } Uses CRT; Var x,y,z : Real; Tecla : Char; Begin ClrScr; Write('X = '); Readln(x); Write('Y = '); Readln(y); Write('Z = '); Readln(z); Writeln;Writeln; If (x<y+z) and (y<x+z) and (z<x+y) Then If (x=y) and (x=z)
Then Writeln('TRIÂNGULO EQUILÁTERO') Else If (x=y) Or (x=z) Or (y=z) Then Writeln('TRIÂNGULO ISÓSCELES') Else Writeln('TRIÂNGULO ESCALENO') Else Writeln('X,Y,Z NÃO SÃO LADOS DE UM TRIÂNGULO'); ReadKey; End.
V.4 – Case: Esta instrução nos permite selecionar uma opção baseada no valor de uma variável ou expressão. Existem duas sintaxes, a saber:
Sintaxe número 1:
Case <expressão ou variável> of <valor 1> : Comando_1; <valor 2> : Comando_2;
... : Comando_n; End;
Ou
Case <expressão ou variável> of <valor 1> : Begin comando_1; comando_2;
... End; <valor 2> : Begin comando_1; comando_2; ... End; ... ... : Begin comando_1; comando_2; ... End; End;
A expressão ou variável no comando Case deve ser do tipo simples, normalmente Char ou Integer. Após a avaliação da expressão, seu valor ou o valor da variável é comparado com os diversos valores discriminados. Se houver algum que satisfaça, o(s) comando(s) subsequente(s) será(ão) executado(s).
Sintaxe número 2:
Case <expressão ou variável> of <valor 1> : Comando_1;
