Prioridades

Exemplo 4.4:

bd : array[1..10] of record

Embora a tenham o mesmo sentido quanto a utilização, nesses dois tipos de declaração com vetores de índices as variáveis são referenciados de maneira diferente. Por exemplo, no primeiro caso basta acrescentar um ponto e o nome da variável para referenciar o devido campo. No segundo caso deve-se colocar o nome do tipo do vetor. A seguir, são mostrados os exemplos desses dois casos, quando imprimindo-se os valores do registro do vetor da posição i.

Exemplo 4.5:

Caso 1
writeln(bd[i].nome);
writeln(bd[i].ender.rua);
writeln(bd[i].ender.numero);
writeln(bd[i].ender.CEP);
writeln(bd[i].CPF);
writeln(bd[i].Sexo);
writeln(bd[i].nascimento);
writeln(bd[i].rg);

Caso 2
writeln(bd[i].cadastro.nome);
writeln(bd[i].cadastro.ender.rua);
writeln(bd[i].cadastro.ender.numero);
writeln(bd[i].cadastro.ender.CEP);
writeln(bd[i].cadastro.CPF);
writeln(bd[i].cadastro.Sexo);
writeln(bd[i].cadastro.nascimento);
writeln(bd[i].cadastro.rg);

Arquivos

Antes de se declarar arquivos em um programa, deve ser declarar primeiramente o seu tipo. As formas das declarações é a seguinte:

type identificador-do-tipo = file of tipo;

lista-de-identificadores : identificador-do-arquivo;

type é uma palavra-chave;
identificador-de-tipo é o identificador associado ao novo tipo;
file of são palavras reservadas;
tipo é o tipo a que pertencem os registros do arquivo;
lista-de-identificadores são nomes associados aos arquivos.

Exemplo 4.6:
Aproveitando a declaração do tipo cadastro acima, abaixo seguem exemplos de sua utilização com arquivos.

Type cadastro = record

• .
  .
  .
  .
• end;
• arqcad = file of cadastro;
• var
• arquivo : arqcad;
  arquivo2 : file of cadastro;

Operações com Arquivos

As operações básicas realizadas sobre um arquivo são abertura, leitura, escrita e fechamento.

A abertura de arquivos corresponde à ação de se associar o arquivo declarado no programa com o arquivo físico. O primeiro registro do arquivo fica disponível para leitura através do seguinte comando:

reset(nome-do-arquivo);

Caso o arquivo já exista, para começar a escrever novamente no arquivo, ignorando-se os registros anteriores, utiliza-se o seguinte comando:

rewrite(nome-do-arquivo);

O nome-do-arquivo é o identificador do arquivo no programa. Para se fazer uma associação desta identificação interna com a identificação externa, usa-se o comando assign, cuja forma é:

assign(nome-do-arquivo,'nome-externo');

nome-externo é o nome pelo qual o arquivo é conhecido externamente ao programa.

O comando assign deve anteceder a abertura do arquivo e nunca deve ser utilizado quando o arquivo já estiver sendo manipulado.

O fechamento do arquivo desvincula o arquivo do programa, atualizando as informações do arquivo no ambiente do sistema operacional. Para se fechar um arquivo, usa-se o comando:

close(nome-do-arquivo);

Para ler um arquivo, ou seja ler o seu conteúdo, é utilizado o seguinte comando:

read(nome-do-arquivo,registro);

Esse comando lê o conteúdo do registro corrente do arquivo associado à nome-do-arquivo e armazena-o em na variável registro, que deve ser do mesmo tipo do arquivo. Após a execução desse comando, o registro corrente é lido, e o próximo passa a ser o registro corrente.

Para escrever em um arquivo, é utilizado o seguinte comando:

write(nome-do-arquivo,registro);

Esse comando, quando executado, grava no registro corrente do arquivo associado à nome-do-arquivo o conteúdo da variável registro.

Usando somente os comandos read e write, os registros estão acessíveis somente seqüencialmente, ou seja, um registro será acessado somente após todos os seus anteriores sejam acessados.

É possível acessar um registro qualquer do arquivo diretamente, desde que se saiba a sua posição física no arquivo. Esse tipo de acesso é conseguido pelo comando:

seek(nome-do-arquivo,n);

Com esse comando é possível acessar o n-ésimo registro do arquivo associado à nome-do-arquivo, caso n seja menor que o número de registros do arquivo. O primeiro registro é o de número 0 (zero).

Para se obter o número de registros de um arquivo, utiliza-se o comando:

filesize(nome-do-arquivo);

Com a utilização dos comandos seek e filesize temos um outro tipo de organização ou acesso aos arquivos: a organização direta. Neste caso temos que escolher uma chave para indexar os registros, ou seja, essa chave será utilizada para indicar em que posição no arquivo um registro será armazenado.

Exemplo 4.7:

program sequencial;

type
endereço = record

• rua : string[40];
  numero : integer;
  CEP : real;
• end;
• cadastro = record
• nome : string[30];
  ender : endereço;
  CPF: real;
  Sexo : char;
  nascimento : real;
  rg : real;
• end;
• arqcad = file of cadastro;

var

• arq_in, arq_out : arqcad;
  reg: cadastro;

begin

• assign(arq_out,'sample.dat'); {associando nome interno com nome externo}
  rewrite(arq_out); {abrindo arquivo para gravação}
  write('Nome: ');
  readln(reg.nome);
  while (reg.nome <> 'fim') do
• begin
• write('Rua: ');
  readln(reg.ender.rua);
  write('Numero: ');
  readln(reg.ender.numero);
  write('CEP: ');
  readln(reg.ender.CEP);
  write('CPF: ');
  readln(reg.CPF);
  write('Sexo(M/F): ');
  readln(reg.Sexo);
  write('Data de Nascimento(dd/mm/aaaa): ');
  readln(reg.nascimento);
  write('RG: ');
  readln(reg.rg);
  write(arq_out,reg); {grava registro após o último registro do arquivo}
  readln(reg.nome);

• begin
• write(reg.ender,rua,' ');
  write(reg.ender.numero,' ');
  write(reg.ender.CEP,' ');
  write(reg.CPF,' ');
  write(reg.Sexo,' ');
  write(reg.nascimento,' ');
  writeln(reg.rg,' ');

end.

Este programa a seguir exemplifica a utilização dos comando seek. Neste caso assumimos que as chaves estão no intervalo entre 1 e 100.

program acesso_direto;

type
endereço = record

• rua : string[40];
  numero : integer;
  CEP : real;
• end;
• cadastro = record
• chave : integer;
  nome : string[30];
  ender : endereço;
  CPF: real;
  Sexo : char;
  nascimento : real;
  rg : real;
• end;
• arqcad = file of cadastro;
  tammax = 100;

var

• arq_out : arqcad;
  reg : cadastro;

begin

• assign(arq_out,'sample.dat'); {associando nome interno com nome externo}
  rewrite(arq_out); {abrindo arquivo para gravação}
  write('Chave: ');
  readln(reg.chave);
  while (reg.chave <> 0) do
• begin
• if (reg.chave >= 1) and (reg.chave <= 100) then
• begin
• write('Nome: ');
  readln(reg.nome);
  write('Rua: ');
  readln(reg.ender.rua);
  write('Numero: ');
  readln(reg.ender.numero);
  write('CEP: ');
  readln(reg.ender.CEP);
  write('CPF: ');
  readln(reg.CPF);
  write('Sexo(M/F): ');
  readln(reg.Sexo);
  write('Data de Nascimento(dd/mm/aaaa): ');
  readln(reg.nascimento);
  write('RG: ');
  readln(reg.rg);
  seek(arq_out,chave-1);
  write(arq_out,reg); { grava registro após o último registro do arquivo}

• begin
• writeln('Chave deve estar no intervalo [1,100].');

Arquivos texto

As operações de abertura, de associação entre o nome interno e externo, de fechamento, de leitura, de escrita de um arquivo texto são as mesmas que dos arquivos binários. No entanto, para se declarar um arquivo texto utiliza-se uma outra notação:

lista-de-identificadores:text

lista-de-identificadores são nomes associados aos arquivos declarados como texto.

Outra diferença com relação às operações é a possibilidade de utilização dos comandos readln e writeln sobre arquivos texto, o que não é possível sobre arquivos binários, visto que estes não possuem marca de final de linha. A diferença entre os comandos read e readln, write e writeln é basicamente a mesma quando utilizados como comandos de entrada e saída. Os comandos read e write operam sobre campos, enquanto que os comandos readln e writeln operam sobre linhas.

Exemplos
Esse programa lê um arquivo texto, exibe o seu conteúdo na tela e o número de linhas do arquivo.

program le_arquivo_texto;

var

• entrada : text;
  linha : string[100];
  nlinhas : integer;

begin

• nlinhas = 0;
  assign(entrada,'arq1.txt');
  reset(entrada);
  readln(entrada,linha); {lê cada linha do arquivo}
  while (not EOF(entrada)) do
• begin
• writeln(linha);
  readln(entrada,linha);
  nlinhas := nlinhas + 1;

end.

O próximo programa lê 10 linhas contendo três campos do tipo inteiro, lê 10 linhas contendo três campos do tipo real, somando os valores de cada linha e colocando o resuldato em um arquivo de saída. O programa assume que o arquivo de entrada já esteja no formato correto.

program le_valores_inteiro_real;

var

• arq_in, arq_out : text;
  vi1, vi2, vi3, somai : integer;
  vr1, vr2, vr3, somar : real;
  i : integer;

begin

• assign(arq_in,'dados.txt');
  assign(arq_out,'saida.txt');
  reset(arq_in);
  rewrite(arq_out);
  for i:= 1 to 10 do
• begin
• readln(arq_in,vi1,vi1,vi3);
  somai := vi1 + vi2 + vi3;
  writeln(arq_out,'linha ',i ,' - soma = ',somai);

• begin
• readln(arq_in,vr1,vr1,vr3);
  somar := vr1 + vr2 + vr3;
  writeln(arq_out, 'linha ',i+10 ,' - soma = ',somar:10:4);

end.

Exemplo do conteúdo do arquivo dados.txt:

10  11  12
13  14  15
16  17  18
19  20  21
22  23  24
25  26  27
28  29  30
31  32  33
34  35  36
37  38  39
50.00  51.10  52.20
53.30  54.40  55.50
56.60  57.70  58.80
59.90  60.00  61.10
62.20  63.30  64.40
65.50  66.60  67.70
68.80  69.90  70.00
71.10  72.20  73.30
74.40  75.50  76.60
77.70  78.80  79.90

Variáveis locais com o mesmo identificador declaradas em módulos diferentes e no mesmo nível são invisíveis umas para o outras, ou seja, não causam conflito. Quando os módulos estão aninhados, as variáveis declaradas em cada módulo, podem ser vistas e/ou utilizadas pelos respectivos sub-módulos. Porém, não serão utilizadas se forem declaradas variáveis com o mesmo identificador em seus sub-módulos, onde valerá somente as variáveis locais. Ou seja, se forem declaradas variáveis locais em um módulo A com o mesmo identificador que as variáveis globais à A, valerá as variáveis locais. Isso define as regras de escopo das variáveis, ou seja, até onde as variáveis podem ser utilizadas e/ou visíveis à outros módulos. No caso de existirem variáveis locais e globais com o mesmo nome, alterações feitas nas variáveis locais não afetam as globais. Já no caso onde um variável global é modificada, o próximo instrução que acessá-la irá encontrar o valor dessa última atualização.

Exemplo:

program A;
{ declaração de variáveis }
var m, n : real;

• procedure B;
  { declaração de variáveis }
  var i, j : integer;
  begin
  { corpo do procedimento B }
  end;

• procedure D;
  { declaração de variáveis }
  var k, l : integer;
  begin
  { corpo do procedimento D }
  end;

begin

{ corpo do programa principal }

end.

• As variáveis i e j declaradas nos procedimentos A e B são invisíveis entre si, portanto não causam conflito.
• As variáveis k e l são válidas como inteiros em C. Apesar de serem globais, são invisíveis a D, pois foram redeclaradas como tipo real. É como se k e l fossem declaradas com outros identificadores.
• As variáveis i e j declaradas em C são globais a D, assim como as variáveis m e n são globais à todos os procedimentos.

A declaração de um procedimento em Pascal é constituída de um cabeçalho e de um corpo. O cabeçalho identifica o procedimento através de um nome, e o corpo contém as declarações dos objetos locais, além de comandos e estruturas do procedimento. A ativação de um procedimento, atendidas às condições de escopo, é feita através da referência ao seu nome em algum ponto do programa. Em Pascal existem dois tipos de procedimentos: procedure e function. Não confunda procedimento com a tradução de procedure, pois esta última é uma palavra reservada do Pascal, que define um tipo de procedimento.

O objetivo de se declarar uma procedure é associá-la a um identificador para que a mesma possa ser ativada por um comando do programa. A sua declaração é feita da seguinte forma:

procedure nome;
declaração dos objetos locais à procedure
BEGIN
comandos da procedure
END;

A chamada ou ativação de uma procedure é feita referenciando-se o seu nome no local do programa onde a mesma deve ser ativada, ou seja, onde a sua execução deve ser iniciada. Ao terminar a execução dos comandos de um procedure, a seqüência do programa retorna sempre à instrução seguinte que provocou a sua chamada. A nível de execução, a chamada de uma procedure valeria como se fosse feita uma cópia dos comandos do procedimento no local do programa onde foi ativada, ajustando-se os objetos locais para atender as regras de escopo.

Exemplo:

program procedimentos;
var
{ declaração das variáveis do programa principal }

• procedure entrada_de_dados;
  var
  { declaração das variáveis do procedimento entrad_de_dados }
  begin
  { comandos do procedimento entrada_de_dados }
  end;

begin
{ corpo programa principal }
    entrada_de_dados;
    processa_dados;
    imprime_resultados;
end.

Este exemplo ilustra como procedimentos podem facilitar o entendimento do programa. Neste caso, o corpo do programa principal se constitui apenas de três chamadas à procedimentos.

A declaração de uma function tem como objetivo associá-la a um identificador para que possa se ativada em uma expressão do programa. A declaração de uma function é feita da seguinte forma:

function nome: t
declararão dos objetos locais à function
BEGIN
comandos da function
.
.
.
nome := X;
END;

t é tipo que a função irá retornar. X é o valor do mesmo tipo t que será retornado pela função. Vemos aqui que o corpo da função precisa necessariamente conter um comando de atribuição no qual o nome da function aparece à esquerda do sinal de atribuição. A ativação de uma function é feita posicionando-se o nome da mesma em uma expressão de mesmo tipo.

Exemplo:

program exemplo_function;
{ program que calcula o fatorial de N com a utilização de uma função }
var N : integer;

• function fatorial : integer;
  var i, acumul : integer;
  begin
• acumul := 1;
  i := 1;
  while (i <= N) do
  begin
      acumul := acumul * i;
      i := i + 1;
  end;
  fatorial := acumul;

begin
    write('Digite o valor de N: ');
    readln(N);
    writeln('O valor do Fatorial de ',N , ' é = ', fatorial);
end.

A utilização de variáveis globais, no entanto, não constitui uma boa prática de programação, visto que podem amarrar os procedimentos (tornando-os dependentes) e quebrar a questão de modularidade. Em um procedimento, as suas variáveis locais tem vida somente durante a sua execução. ou seja, são criadas e alocadas quando no momento da ativação, e liberadas quando de seu término. Além do mais, essas variáveis não podem ser acessadas pelos níveis externos ao procedimento. Então, para transmissão de informações de dentro para fora dos procedimentos a linguagem Pascal utiliza o mecanismo de parâmetros.

Por meio dos parâmetros faz-se a comunicação de fora para dentro e de dentro para fora de um procedimento, o que torna o módulos independentes e reutilizáveis em outros programas. Os parâmetros são objetos utilizados dentro do procedimento e representam os objetos do nível mais externo (parâmetros de definição). Para declarar procedures e functions que utilizam parâmetros basta acrescentar ao cabeçalho a lista de parâmetros a ser utilizada, que deverá estar entre parênteses. Isso é feito da seguinte forma:

procedure nome(lista-de-parametros);

function nome(lista-de-parametros);

lista-de-parametros é da forma: parâmetro1 : tipo, parâmetro2 : tipo, ..., parâmetron: tipo.

A ativação de um procedimento se faz por meio de uma referência a seu nome seguido pela lista de parâmetros envolvida por parênteses. Esses parâmetros são conhecidos por parâmetros de chamada, e podem ser constantes, variáveis ou expressões dos módulos externos cujos valores serão transmitidos para os parâmetros de definição do procedimento e após a sua execução receberão de volta, ou não, os valores contidos no parâmetros de definição. Dependendo de como são declarados os parâmetros de definição no procedimento, é determinado se os parâmetros de chamada conterão ou não os valores contidos nos parâmetros de definição. Isso define o modo de passagem dos parâmetros: passagem por referência e passagem por valor. Quando se declara um parâmetro como sendo de referência, as atribuições à ele são refletidas no parâmetro de chamada correspondente, após a execução do procedimento o parâmetro de chamada conterá o mesmo valor que o parâmetro de definição correspondente. Para especificar se um parâmetro terá passagem por referência, a sua declaração deverá ser precedida pela palavra-chave var.

Caso a declaração não seja precedida por var, então o parâmetro possui passagem por valor. Neste caso, os parâmetros de definição conterão os mesmos valores de seus parâmetros de chamada correspondente no momento da ativação, mas alterações nos parâmetros de definição não serão refletidas nos parâmetros de chamada correspondente. Pode-se dizer também que um parâmetro com passagem por referência é um parâmetro de entrada e saída, enquanto que um parâmetro com passagem por valor é um parâmetro de entrada.

Exemplo:

program exemplo_function_2;
{ program que calcula o fatorial de N com a utilização de uma função
com passagem de parâmetros }
var N : integer;

• function fatorial(fat : integer): integer;
  var i, acumul : integer;
  begin
        acumul := 1;
        i := 1;
        while (i <= fat) do
        begin
            acumul := acumul * i;
            i := i + 1;
        end;
        fatorial := acumul;
  end;

begin   write('Digite o valor de N: ');
  readln(N);
  writeln('O valor do Fatorial de ',N , ' é = ', fatorial(N));
end.

program exemplo_procedure_2;
{ programa que utiliza uma procedure para ler os valores em uma matriz
N x M e uma procedure que imprime os valores de uma matriz M x N }
const
M = 10;
N = 10;

type
matriz = array[1..M,1..N] of integer;
var
    a : matriz;
    numlin, numcol : integer;

• procedure le_matriz(var mat : matriz; lin, col : integer);
  var i, j : integer;
  begin
      for i:= 1 to lin do
          for j := 1 to col do
              read(mat[i,j]);
  end;

begin { programa principal }
    write('Entre com o número de linhas da matriz (<',M, '): ');
    readln(num_lin);
    write('Entre com o número de colunas da matriz (<',N, '): ');
    readln(num_col);
    le_matriz(a,num_lin,num_col);
    imprime_matriz(a,num_lin, num_col);
end.