Caracteres utilizados
Os caracteres que podem ser
utilizados no Turbo Pascal são divididos em:
Letras:
'A' até 'Z', 'a' até 'z'
Números:
0,1,2,3,4,5,6,7,8 e 9
Especiais:
+ - * / = ^ < > ( ) [ ] { } . , : ; ' # $
Observações:
1-) O Turbo Pascal não faz distinção entre letras maiúsculas e
minúsculas, de tal forma que no desenvolvimento deste curso eu utilizarei os
dois tipos da forma que achar mais conveniente.
2-) Embora na maioria das linguagens o sinal de atribuição de
valores a variáveis seja o =, em
Pascal, o símbolo de atribuição é
:=,
exemplos:
A = 100 em Basic
A := 100 em Pascal
3-) Dois pontos em seguida (..) indica um delimitador de faixa,
exemplo:
1..30 -->
todos inteiros entre 1 e 30 inclusive.
Palavras reservadas
As palavras reservadas do Turbo
Pascal são palavras que fazem parte da sua
estrutura e têm significados pré-determinados. Elas não podem ser
redefinidas e não podem ser utilizadas
como identificadores de variáveis, procedures, functions etc. Algumas das
palavras reservadas são:
absolute(*)
|
and
|
array
|
begin
|
case
|
const
|
div
|
do
|
downto
|
else
|
end
|
external(*)
|
file
|
for
|
forward
|
function
|
goto
|
if
|
in
|
inline(*)
|
label
|
mod
|
nil
|
not
|
of
|
or
|
packed
|
procedure
|
program
|
record
|
repeat
|
set
|
shl(*)
|
shr(*)
|
string(*)
|
then
|
to
|
type
|
until
|
var
|
while
|
with
|
xor(*)
|
(*) --> não definidos no
Pascal Standard
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 estão sendo criadas pela Borland International (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á é.
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 formados 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 ser palavra reservada.
Exemplos de identificadores
válidos:
Meu_Nome
MEU_NOME igual ao anterior
__Linha
Exemplo23
Exemplos de identificadores não válidos:
2teste : começa com
número
Exemplo 23 : tem um espaço
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.
Números
No Turbo Pascal, podemos
trabalhar com números inteiros e reais, sendo que os números inteiros podem ser
representados na forma hexadecimal, para tanto, basta precedê-los do símbolo $. Os números reais
também podem ser representados na forma exponencial.
Isso tudo varia de versão para
versão do turbo Pascal, citarei aqui 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
|
Strings
Strings são conjunto de
caracteres entre aspas simples.
Exemplos:
'isto é uma string'
'123456' etc.
Caracteres de controle
Existem alguns caracteres que têm
significados especiais. São os caracteres de controle. Exemplos:
Control G =>
Bell ou beep
Contorl L => Form Feed
etc.
Em Turbo Pascal, também podemos
utilizar estes caracteres. Para tanto, eles devem ser escritos pelo seus
valores ASCII correspondentes, precedidos do símbolo #, ou então a letra correspondente precedida do símbolo ^.
Exemplo: Control G => #7 ou ^G
Definição de variáveis
Como já dissemos, todas as
variáveis que forem utilizadas no corpo do programa, devem ser declaradas numa
subárea específica chamada Var.
Para estudarmos essa subárea
devemos primeiro ver os tipos de variáveis pré-definidos em Turbo Pascal.
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
- todos os tipos de reais
citados acima
Escalares estruturados:
- String
- Array
- Record
- File
- Set
- 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 tais como dígitos, letras e símbolos tais como &, #,* etc.
Os caracteres devem vir entre
aspas simples. ('José')
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.
SHORTINT - INTEGER - LONGINT
- BYTE
- WORD:
Ver tabela acima.
REAL - SINGLE - DOUBLE
- EXTENDED
- COMP:
Ver tabela acima.
A declaração Var
Esta é a subárea onde devemos
declarar todas as variáveis que iremos utilizar em nosso programa. Exemplo:
Program Exemplo; (*
cabeçalho do programa *)
Var
idade,número_de_filhos : byte;
altura :
real;
sexo :
char;
nome :
string[30];
sim_ou_não : boolean;
quantidade : integer;
(* aqui começa o programa *)
Begin
idade:=34;
número_de_filhos:=2;
sexo:='M';
nome:='José';
sim_ou_nao:=TRUE;
quantidade:=3245;
End.
Observações importantes:
1-) A palavra reservada Var aparece uma única vez num
programa
2-) A sintaxe geral para declaração de variáveis é:
variável_1,variável_2,...,variável_n :
tipo;
3-) Os espaços e comentários separam os elementos da linguagem.
Você pode colocar quantos espaços quiser. Observe:
Varidade: integer; o compilador não reconhece a palavra Var
Var idade:integer; agora sim, ou se preferir
Var idade
: integer; dá na mesma.
4-) As instruções são separadas entre si por ponto e vírgula ';'.
Se você quiser, pode colocar mais de uma instrução numa única linha. Lembre-se
que o limite de caracteres numa linha é de 127
5-) O tipo string deve ser procedido da quantidade máxima de
caracteres que a variável pode assumir. Lembre-se que a alocação de espaço de
memória para as variáveis é feita durante a compilação, portanto o compilador
precisa saber desse dado. Por outro lado, o fato de termos, por exemplo,
atribuído o valor máximo de 30 não significa que tenhamos que utilizar os 30 caracteres e sim no máximo 30.
6-) Como última observação, acho muito mais claro e elegante declarar
variáveis e ao mesmo tempo informar com linhas comentários os devidos motivos.
Exemplo:
Var
idade, (*
idade de determinada pessoa *)
i,j (*
utilizadas em loops *)
: integer;
nome1, (* nome genérico de pessoas *)
nome2 (*
nome genérico de pessoas *)
: string[50];
A declaração type
Além dos tipos de dados
pré-definidos no Turbo Pascal, podemos também definir novos tipos através da
declaraçäo Type. A sua sintaxe geral é:
Type identificador =
(valor1,valor2,valor3,valor4, ... ,valorN);
O identificador deve seguir as
regras dadas anteriormente e entre os parentêses estão os valores que podem ser
assumidos. Exemplos:
Type
cor =
(azul,vermelho,branco,verde,amarelo);
dia_útil =
(segunda,terça,quarta,quinta,sexta);
linha = string[80];
idade = 1..99;
(* a partir deste instante, além dos tipos de dados pré-definidos,
podemos também utilizar os novos tipos definidos cor,dia_útil, linha e idade *)
Var
i : integer;
d : idade;
nome
: linha;
dia : dia_útil;
cores : cor;
(* etc. *)
Observação: Quando damos os valores que os dados podem
assumir através da declaração type, o Turbo Pascal assume, automaticamente, que o valor da direita vale
mais que o da esquerda e assim. Por exemplo: no caso da definição de cor,
amarelo vale mais que verde, que por sua vez vale mais que branco e assim por diante.
Constantes
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.
Constantes pré-definidas
Existem algumas constantes pré-definidas
e que podemos utilizá-las sem ter que declará-las. São elas:
PI = 3.1415926536E + 00
FALSE
TRUE
NIL Pointer nulo, veremos
mais adiante.
MAXINT = 32767
Constantes tipadas
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 atribua valores a elas, seus valores serão desconhecidos.
Sob certas circunstâncias, seria interessante que pudéssemos ao mesmo tempo em
que declaramos a variável, dar seu valor inicial. Isto é possível com o
conceito de constante tipada cuja sintaxe é:
Const variável : tipo = valor;
Exemplos:
const Contador : integer = 100;
c : char = 'A';
Estamos definindo duas variáveis,
uma chamada contador que é inteira e vale inicialmente 100, e outra chamada c
que é do tipo char e cujo valor inicial é 'A'.
Operadores
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
|
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.
Operadores lógicos
AND
E lógico
OR
OU lógico
XOR
OU EXCLUSIVO lógico
Estes operadores só aceitam como
operandos, valores lógicos, ou seja :
TRUE e FALSE .
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.
Exemplo:
{PROGRAMA UTILIZANDO OS OPERADORES LÓGICOS}
Program
operadores_logicos;
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 *);
End.
III.4.3 - Operadores relacionais
O Turbo Pascal possui ao todo 7
operadores relacionais que são muito
utilizados nas tomadas de decisões, são eles:
= igual
<> diferente
> maior que
< menor que
>= maior ou igual que
<= menor ou igual que
IN testa se um elemento está incluso em um
conjunto
Exemplos:
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
A avaliação será verdadeira se
uma ou outra expressão for verdadeira, no caso, como C < D então a resposta
é TRUE
Operadores entre bits
Os operadores entre bits só podem
ser aplicados em dados dos tipos byte
ou integer e o resultado é do tipo integer. Eles agem bit a bit e podem ser
aplicados na notação hexadecimal ou decimal. São eles:
SHL -
SHift Left
Desloca n bits à esquerda. Durante o deslocamento, os
bits à esquerda são perdidos e dígitos zeros preenchem a posição direita.
Exemplos:
1-) Se X = 00010101 então
X shl 2 = 01010100
X
shl 5 = 10100000
2-) 55 shl 3 = 184
55 = 00110111 deslocando 3 à esquerda ficaria:
10111000 que é igual a 184
3-) $F0 shl 2 = $C0
$F0 = 11110000 deslocando 2 à esquerda
ficaria:
11000000 que é igual a $C0
SHR - SHift Right
Desloca n bits à direita. Durante
o deslocamento, os bits à esquerda são preenchidos com zeros e os da direita
são perdidos. Exemplos:
1-) Se X = 10101100 então
X shr 3 = 00010101
X shr 6 = 00000010
2-) 55 shr 3 = 6
55 = 00110111 deslocando 3 à direita
ficaria:
00000110 que é igual a 6
3-) $F0 shr 2 = $3C
$F0 = 11110000 deslocando 2 à direita
ficaria:
00111100 que é igual a $3C
Observação.: Nós operamos na base 10, porque trabalhamos
com 10 algarismos, 0..9, certo? Bem na base 2 operamos somente com 2
algarismos, o 0 e o 1. Dessa forma, temos que representar todos os números da
base 10 utilizando somente o 0 e 1. Parece complicado ? Nem tanto, veja abaixo
a correspondência:
BASE 10 BASE 2
0 0
1 1
2 10
3 11
4 100
5 101
6
110
7 111
8 1000
9 1001
10 1010
11 1011
e assim por diante
Para converter um número da base 10 para a base
2, basta dividir o número, o qual queremos converter, por dois sucessivamente
até que o resto seja 0, depois pegamos os restos de baixo para cima.
Exemplo:
(23) => (
)
10 2
23 / 2 dá 11 e sobra 1
11 / 2 dá 5 e
sobra 1
5 / 2 dá 2 e
sobra 1
2 / 2 dá 1 e
sobra 0
1 / 2 dá 0 e
sobra 1
Portanto (23) => (10111)
10 2
Para converter da base 2 para a
base 10, devemos fazer ao contrário:
(10111) => (
)
2 10
4
3 2 1 0
(
1 0 1
1 1 )
1 x 24 + 0 x 23 + 1 x 22 + 1 x 20 + 1 x 2 =
16
+ 0 +
4 + 2
+ 1 = 23
NOT
O operador NOT nega os bits, isto é os bits iguais a 1 se tornam 0 e os bits
zero se tornam 1. Devemos lembrar, no entanto, que os inteiros possuem 2 bytes,
portanto, ao se trabalhar com números decimais inteiros
será afetado o byte de mais alta ordem e
também o sinal. Exemplo:
NOT (255) = -256
Para suprimir este problema, você
deve trabalhar com bytes:
Program Exemplo;
Uses CRT;
Var i,j : Byte;
Begin
ClrScr;
i:=255;
j:=NOT(i);
Writeln(j); (*
será escrito 0 *)
End.
AND
Este operador realiza a operação E lógico bit a bit. Relembrando, a
operação E resulta em 1 se e somente se os dois operandos
forem iguais a 1, caso contrário, o resultado será igual a 0. Exemplos:
1-) $0F AND $F0 = $0 pois
$0F = 00001111
$F0 = 11110000
00001111 AND 11110000 = 00000000
2-) 255 AND 55 = 55 pois
255
= 11111111
55 = 00110111
11111111 AND 00110111 = 00110111
3-)
34 AND 76 = 0 pois
34
= 00100010
76
= 01001100
00100010 AND 01001100 = 00000000
OR
Este operador realiza a operação OU lógico bit a bit. Relembrando, a
operação OU resulta em 1 se um ou os dois operandos forem iguais a 1.
Exemplos:
1-) $0F OR $F0 = $FF pois
$0F = 00001111
$F0
= 11110000
00001111 OR 11110000 = 11111111
2-) 255 OR 55 = 255 pois
255
= 11111111
55 = 00110111
11111111 OR 00110111 = 11111111
3-) 34 OR 76 = 110 pois
34 =
00100010
76 =
01001100
00100010 OR 01001100 = 01101110
XOR
Este operador realiza a
operação OU EXCLUSIVO lógico bit a
bit. Relembrando, a operação OU EXCLUSIVO resulta em 1 se os operandos forem
diferentes entre si . Exemplos:
1-) $0F XOR $F0 = $FF pois
$0F = 00001111
$F0
= 11110000
00001111 XOR 11110000 = 11111111
2-) 255 XOR 55 = 200 pois
255 = 11111111
55
= 00110111
11111111 XOR 00110111 = 11001000
3-) 34 XOR 76 = 110 pois
34 = 00100010
76 = 01001100
00100010 XOR 01001100 = 01101110
Concatenação
Esta operação é representada pelo
sinal de adição, ou seja, +. Os operandos devem ser do tipo string ou char.
Exemplo:
'Isto é uma ' + 'string' = 'Isto é uma
string'
Nenhum comentário:
Postar um comentário