Curso de Pascal
Tipos e Conjuntos


  O Pascal oferece opções para criar tipos de dados mais complexos além dos tipos primitivos existentes (integer, real, boolean, char e byte). Assim, exitem três possibilidades de declaração de tipos (type) no Pascal: escalar, array e registro.

  Tipo Escalar

  Além dos tipos primitivos do Pascal, é possível que o usuário defina outros tipos escalares. Assim, o programador define todos os valores possíveis, e em ordem, para uma variável. Ex:
type
  dia = (Segunda, Terca, Quarta, Quinta, Sexta, Sabado, Domingo);
  Boolean = (False, True);

  A seguir, um programa exemplo:
type
  dia = (Segunda, Terca, Quarta, Quinta, Sexta, Sabado, Domingo);

var
  d : dia;

begin
  d := Terca;
  writeln('Dia: ', d);
end.
Saída:
Dia: Terca

  É possível utilizar operadores para comparar dados de um tipos escalar. Operadores aceitos: =, <>, >, <, >=, e <=

  Além disso, é possível determinar o antecessor, o sucessor e o número de ordem: pred(var), succ(var) e ord(var)

Ex:
type
  dia = (Segunda, Terca, Quarta, Quinta, Sexta, Sabado, Domingo);

var
  d : dia;

begin
  writeln('Segunda e menor que Terca? ', Segunda < Terca);
  writeln('Depois da Quarta vem a ', succ(Quarta));
  writeln('Posicao da Sexta: ',ord(Sexta));
  writeln('Dia 3: ',dia(3));
end.
Saída:
Segunda e menor que Terca? TRUE
Depois da Quarta vem a Quinta
Posicao da Sexta: 4
Dia 3: Quinta

  É possível definirmos um subconjunto de dados consecutivos chamado de subrange. Ex:
type
  dia = (Segunda, Terca, Quarta, Quinta, Sexta, Sabado, Domingo);
  dia_util = (Segunda..Sexta);

  Tipo Array

  Difine uma variável do tipo vetor (array). Ex:
type
  nota = array[1..10] of integer;
  nome = String[40];

var
  n : nota;
  p : nome;

begin
  n[4] := 6;
  p := 'Katia';
end.

  Tipo Registro (Record)

  Difine um registro contendo variáveis de diversos tipos. É como uma "variável composta". Ex:
type
  varficha = record
    nome : string[40];
    dia, mes, ano : integer;
    endereco : string[255];
  end;

  Para usarmos no programa, basta declarar a variável ficha do tipo varficha criada por você. Ex:
var ficha : varficha;
  O acesso a cada variável de dentro do registro é feito através do nome da variável mais um ponto (.) e o nome da variável do registro. Por exemplo, para acessar o nome da ficha, faz-se:
ficha.nome := 'Jose';
  Preenchendo todos os dados (corpo principal do programa):
begin
  ficha.nome := 'Guga';
  ficha.dia := 10;
  ficha.mes :=  9;
  ficha.ano := 1976;
  ficha.endereco := 'Floripa';
end;
  Para crirar um vetor de "varficha", é simples:
var ficha : array[1..20] of varficha;
  Um programa completo para inserir 20 nomes no array de varficha:
type
  varficha = record
    nome : string[40];
    dia, mes, ano : integer;
    endereco : string[255];
  end;

var ficha : array[1..20] of varficha;
    i : integer;

begin
  for i:=1 to 20 do
  begin
    writeln('Pessoa numero ',i);
    write('Nome: ');
    readln(ficha[i].nome);
    write('Dia de nascimento: ');
    readln(ficha[i].dia);
    write('Mes de nascimento:  ');
    readln(ficha[i].mes);
    write('Ano de nascimento:  ');
    readln(ficha[i].ano);
    write('Endereco: ');
    readln(ficha[i].endereco);
  end;
end.


 O uso do with

  De forma a evitar escrever sentenças longas contendo o nome da variável mais o campo, como "ficha.endereço", podemos utilizar a palavra with para representar "ficha". Exemplo:
type varficha = record
       nome : string[40];
       idade : integer;
       dia, mes, ano : integer;
       endereco : string[255];
     end;

var ficha : varficha;

begin
 with ficha do
 begin
   nome := 'Guga';
   dia := 10;
   mes :=  9;
   ano := 1976;
   endereco := 'Floripa';  
 end;
end.


 Tipo registro variante [1]

  O Pascal permite a criação de registros com partes variantes, dependendo do valor contido no campo chave. Veja o exemplo a seguir.
type tipo_escolaridade = (ensino_medio, universidade);
     tipo_aluno = record
       nome : string[40];
       idade : integer;
       case escolaridade : tipo_escolaridade of
         ensino_medio : (serie : integer);
         universidade : (curso : string[20]; periodo : integer);     end;

var aluno : tipo_aluno;

begin
  aluno.escolaridade := ensino_medio;

  aluno.nome := 'Paola';
  aluno.idade := 8;
  aluno.serie := 2; { parte variante }
end.

  O campo "escolaridade" é o campo chave. Assim, esse registro terá uma forma diferente, dependendo do valor da escolaridade.
  Somente podemos ter uma parte variante por registro e essa parte deverá vir depois das partes fixas, que no exemplo anterior são os campos "nome" e "idade".


 Inicialização de tipos no Pascal

  Apesar dos compiladores de Pascal atuais aceitarem a inicialização de variáveis, no Turbo Pascal isso somente é possível quando o tipo é criado como constante.
  A regra de atribuição é a seguinte [2]:
( variavel_1 : valor; ...; variável_n : valor );

  Exemplos:
type 
  ficha = record
    nome : string[10];
    idade : integer;
    peso : real;
  end;

const ficha_medica : ficha = (nome : 'Katia'; idade : 25; peso : 60.2);

begin
  writeln('Nome: ', ficha_medica.nome);
  writeln('Idade: ', ficha_medica.idade);
  writeln('Peso: ', ficha_medica.peso:2:1);
end.
  Saída:
  Nome: Katia
  Idade: 25
  Peso: 60.2


  Com vetor:
type 
  ficha = record
    nome : string[10];
    idade : integer;
    peso : real;
  end;

const paciente : array[1..3] of ficha = (
    (nome : 'Katia'; idade : 25; peso : 60.2), 
    (nome : 'Marta'; idade : 22; peso : 54.7), 
    (nome : 'Fabiana'; idade : 23; peso : 58.2)
  );

var i : integer;

begin
  for i:=1 to 3 do
  begin
    writeln('Paciente no. ', i);
    writeln(' Nome: ', paciente[i].nome);
    writeln(' Idade: ', paciente[i].idade);
    writeln(' Peso: ', paciente[i].peso:2:1);
    writeln;
  end;
end.
  Saída:
  Paciente no. 1
    Nome: Katia
    Idade: 25
    Peso: 60.2

  Paciente no. 2
    Nome: Marta
    Idade: 22
    Peso: 54.7

  Paciente no. 3
    Nome: Fabiana
    Idade: 23
    Peso: 58.2



  Conjuntos

  O conjunto define uma coleção de objetos relacionados entre si. Em Pascal, segue as mesmas definições de conjuntos da matemática.
  Os conjuntos podem ser:
  A palavra reservada "set" define um conjunto no Pascal. Exemplos:
type dezenas = set of 0..9;
     minusculas = set of 'a'..'z';
     numeros = set of (um, quatro, seis, nove);
     cores = (azul, ciano, amarelo);

  Operadores dos conjuntos:

Operador Expressão Descrição
União A + B Resulta na reunião dos elementos dos dois conjuntos.
Interseção A * B Resulta nos elementos que aparecem nos dois conjuntos.
Complemento A - B Resulta nos elementos de A que não estão contidos em B.
Igualdade A = B Resulta nos elementos de A que não estão contidos em B.
Diferença A <> B Verdade, se A for diferente de B.
Subconjunto A >= B Verdade, se B está contido em A.
Subconjunto A <= B Verdade, se A está contido em B.
Pertence A in B Verdade, se A pertence a B.


  O construtor de conjunto (set constructor) é a especificação de um conjunto onde os elementos são separados por vírgula e envolvidos por colchetes. A variação de dados é denotada pelos dois pontos consecutivos (..). Exemplos:
['M','S','X']
[1..10]
['a'..'z', 'A'..'Z', '0'..'9']
[1, 10..15, 20]
[]

  O termo "[]" denota um conjunto vazio.
  O conjunto [1..5] equivale a [1,2,3,4,5].

  Assim, podemos substituir a sentença:
var c : char;
...
if (c='M') or (c='S') or (c='X') then
  por:
var c : char;
...
if c in ['M','S','X'] then

  Da mesma forma:
if (n>=1) and (n<=9) then
  fica:
if n in [1..9] then

  O exemplo a seguir demonstra como criar conjuntos em variáveis e realizar as operações.
type conj_int = set of byte;

var A, B, C : conj_int;

begin
  A := [1, 2, 3];
  B := [3, 4, 5];
  C := A * B; { Resulta em [3] }
end.
  Obs: a declaração de conjuntos do tipo "integer" não são aceitas porque o conjunto de valores são grandes demais.

  O exemplo a seguir mostra como imprimir os membros de um conjunto.
type conj_int = set of byte;

var A, B, C : conj_int;

procedure elementos(c : char; conj : conj_int);
var i : integer;
begin
  write('Elementos de ',c,': ');
  for i:=1 to 10 do
  begin
    if i in conj then
      write(i,' ');
  end;
  writeln;
end;

begin
  A := [1, 2, 3];
  B := [3, 4, 5];
  C := A * B; { Resulta em [3] }
  elementos('A',A);
  elementos('B',B);
  elementos('C',C);
end.
  Saída:
  Elementos de A: 1 2 3
  Elementos de B: 3 4 5
  Elementos de C: 3



  Referências:

  [1]- Turbo Pascal reference manual, 1988.
  [2]- CPU MSX No. 5, 1988.


<< Anterior Pascal Próxima >>


/MARMSX/CURSOS/PASCAL