Escola Nacional de Ciências Estatísticas

Curso de Graduação em Estatística

(Bacharelado)

Computação

Unidade XI:
Funções e Procedimentos

Professor: Eduardo Corrêa

Data: 12/11/2007

1
 Escola Nacional de Ciências Estatísticas

Introdução

A necessidade de repetir uma determinada seqüência de instruções em vários

lugares de um programa, serviu como motivação para o conceito de sub-rotina: um bloco
de código que recebe um rótulo e que pode ser chamado em vários pontos de um programa.
A linguagem Pascal possui dois tipos de sub-rotinas: funções e procedimentos. Uma
função é usada para calcular um valor, enquanto um procedimento é utilizado para executar
uma determinada ação. Esta unidade apresenta os principais conceitos relacionados ao uso
e criação de sub-rotinas na linguagem Pascal.

XI.1 Procedimentos

Um procedimento (procedure) representa um bloco de código que executa uma ação

específica. Para criar um procedimento em Pascal, o programador deve, obrigatoriamente,
definir duas coisas: o nome do procedimento e um bloco de código associado.
O exemplo da Figura XI.1 ilustra um programa Pascal que possui a definição de um
procedimento simples (sem parâmetros) denominado Mensagem. Este procedimento
exibe uma mensagem na tela e é chamado (executado) duas vezes dentro do programa. A
Figura XI.2 ilustra o resultado da execução do programa.

program ProcDemo; {nome do programa principal}

var X: integer; {variável do programa principal}

Procedure Mensagem; {nome do procedimento}

Begin { begin do procedimento }

writeln(’ * * ENCE * *’); { BLOCO DE CÓDIGO }

writeln(’=============’); { DO PROCEDIMENTO }

end; { end do procedimento }

begin {BEGIN do programa principal}

writeln;
Mensagem; {chamada ao procedimento Mensagem}
writeln;
For X:=1 to 10 do writeln(X, ’ ao quadrado = ‘, X*X);
writeln;
Mensagem; {outra chamada ao procedimento Mensagem}
readln;
end. {END do programa principal}
Figura XI.1 – Criação de um procedimento simples.

2
 Escola Nacional de Ciências Estatísticas

Figura XI.2 – Execução do programa ProcDemo.

O programa apresentado na Figura XI.1 começa normalmente com o uso do

comando program na primeira linha e a declaração de uma variável X logo na segunda
linha. A seguir encontra-se uma novidade: a palavra reservada Procedure. Ela informa ao
compilador que um procedimento denominado Mensagem está prestes a ser definido.
Após a definição do nome do procedimento (linha 3), existe a palavra begin (linha 4), para
indicar que o que vem a seguir consiste no bloco de código do procedimento. O
procedimento Mensagem possui os seguintes comandos: imprimir primeiro “* * ENCE *
*” e depois “=============” no vídeo (linhas 5 e 6). A definição do procedimento é
encerrada com o uso do comando end com um ponto-e-vírgula no final (linha 7).
Todo código que vem a seguir é o que chamamos de programa principal (linhas 8
a 16). O programa principal é aquele que já estamos acostumados a fazer neste curso! Ele
começa com um comando begin e termina com o uso do comando end seguido por um
ponto final.
Quando executamos um programa no Dev-Pascal, o primeiro comando a ser
executado é aquele que estiver localizado na primeira linha após o begin do programa
principal (no nosso exemplo é o comando writeln). Observe agora a segunda linha do
programa principal:

Mensagem;

Esta linha consiste em uma chamada para a execução do procedimento definido com
o nome de Mensagem. Quando o computador “vê” esse comando ele sabe que deve
executar todos os comandos que façam parte do bloco de código do procedimento
denominado Mensagem (esses comandos são writeln(’ * * ENCE * *’); e
writeln(’=============’); ). Após executar o comandos da procedure Mensagem, o
computador retorna ao fluxo do programa principal, executando a sua terceira linha
(writeln). A seguir são executadas a quarta e quinta linhas do programa principal ( For
X:=1 to 10 do writeln(X, ’ ao quadrado = ‘, X*X); e writeln) e depois, na
sexta linha existe uma nova chamada ao procedimento Mensagem. Isto faz com que os
comandos do bloco de código deste procedimento sejam executados novamente
(writeln(’ * * ENCE * *’); e writeln(’=============’); ).

3
 Escola Nacional de Ciências Estatísticas

Você pode chamar um procedimento quantas vezes você desejar dentro do

programa principal. Na realidade é para isso mesmo que os procedimentos servem! Para
que possam ser chamados muitas vezes e a partir de locais distintos de um programa.
Agora que você já entendeu o que é um procedimento e a forma básica para a sua
definição e chamada, serão apresentados os principais conceitos relacionados a este
assunto.

XI.1.1 – Escopo de Variáveis: Global x Local

Uma variável é chamada de global quando ela pertence ao programa principal, ou

seja, quando foi declarada na seção de declarações do programa principal.
De maneira oposta, uma variável é chamada de local a um procedimento, quando
ela é declarada dentro da definição de um procedimento.
Uma variável local é visível (existe) apenas dentro do corpo do procedimento a qual
ela pertence. Já a variável global pode ser vista pelo programa principal e por qualquer um
de seus procedimentos. Observe o exemplo das Figuras XI.3 e XI.4.

program Escopo;
var X, Y: integer; {variáveis globais }

Procedure MostraSoma;
var Z: integer; {Z é uma variável local ao procedimento MostraSoma}
begin
Z := X + Y;
Writeln(’SOMA = ‘,Z);
end;

begin
writeln(’ Digite dois numeros ‘); readln(X); readln(Y);
writeln;
MostraSoma;
readln;
end.
Figura XI.3 – Variáveis Globais e Locais

Figura XI.4 – Execução do programa “Escopo”

No exemplo da Figura XI.3, o procedimento MostraSoma executa duas ações:

primeiro soma o conteúdo das variáveis X e Y, lidas a partir do programa principal, e

4
 Escola Nacional de Ciências Estatísticas

armazena em Z. Depois imprime o valor de Z. Observe que MostraSoma pode usar

normalmente as variáveis X e Y, pois elas são variáveis globais.
A variável Z, por sua vez, é local ao procedimento MostraSoma. Isto significa que
ela só existe dentro deste procedimento, que só pode ser enxergada pela procedure
MostraSoma. Ela nasce quando o procedimento é chamado e morre logo que ele acaba de
ser executado! Nem o programa principal e nem qualquer outra procedure diferente de
MostraSoma são capazes de enxergar Z. Para comprovar isso, tente colocar o comando
writeln(Z); dentro do corpo do programa principal (antes do comando readln, por
exemplo). Ao tentar compilar o programa, o Dev-Pascal apresentará o seguinte erro: Error:
Identifier not found Z. Isto ocorre porque o programa principal não conhece nenhum Z. Z é
conhecido apenas pela procedure MostraSoma.

XI.1.2 – Passagem de Parâmetros

O procedimento MostraSoma, do exemplo anterior funciona apenas com as

variáveis globais X e Y. No entanto, imagine que você desejasse construir um
procedimento genérico, capaz de somar qualquer par de variáveis inteiras. Neste caso,
você pode definir um procedimento que aceite parâmetros como entrada. As Figuras XI.5 e
XI.6 demonstram um exemplo deste tipo.

program Parametros;
var X, Y: integer; {variáveis globais }

Procedure MostraSoma(a: integer; b: integer);

var Z: integer; {Z é uma variável local ao procedimento MostraSoma}
begin
Z := a + b;
Writeln(’SOMA = ‘,Z);
end;

begin {programa principal}

writeln(’Digite dois numeros ‘); readln(X); readln(Y);
writeln;
MostraSoma(X,Y);
Writeln;
Writeln(’Agora vou mostrar quanto é 1000 + 2000‘);
MostraSoma(1000,2000);
readln;
end. {fim do programa principal}
Figura XI.5 – Procedimento com Parâmetros de Entrada

5
 Escola Nacional de Ciências Estatísticas

Figura XI.6 – Execução do programa “Parametros”

Veja que o nome do procedimento MostraSoma agora aparece seguido de dois

parâmetros: a e b, que são inteiros. Quando MostraSoma é chamada pela primeira vez no
programa principal (linha 3, do programa principal), os valores das variáveis X e Y são
passados como entrada para o procedimento. Na instrução MostraSoma(X,Y), X
fornece o valor para o parâmetro a, enquanto Y fornece o valor para o parâmetro b. Isso
quer dizer que, quando o procedimento é chamado, a assume o valor de X e b assume o
valor de Y.
A mesma lógica se aplica a segunda chamada do procedimento MostraSoma
(linha 6, do programa principal), quando os valores 1000 e 2000 são escolhidos como
parâmetros. Neste caso, note que ao invés de variáveis, números foram especificados como
parâmetros de entrada. Isso é perfeitamente possível, porque o procedimento
MostraSoma não modifica os valores dos parâmetros a e b (ele apenas os usa para
computar Z). A seção a seguir apresenta maiores detalhes sobre este assunto.

XI.1.3 – Parâmetros de Valor x Parâmetros de Referência

Os parâmetros de um procedimento podem ser especificados de duas formas

distintas: como parâmetros de valor e como parâmetros de referência.
Quando uma variável é passada para um procedimento como parâmetro de valor,
qualquer alteração em seu conteúdo que tenha sido realizada dentro do bloco de código do
procedimento, não é refletida para o programa principal. De maneira oposta, se uma
variável é passada para um procedimento como parâmetro de referência, as alterações
feitas nessa variável durante a execução procedimento serão permanentes, ou seja, serão
refletidas para o programa principal. Para especificar um parâmetro como referência em
um procedimento, é necessário utilizar a palavra reservada var antes do nome do
parâmetro.
Os exemplos das Figuras XI.7 e XI.8 ilustram com maior clareza os conceitos
descritos.

6
 Escola Nacional de Ciências Estatísticas

program Valor_e_Referencia;
var X, Y: integer; {variáveis globais }

Procedure ProcExemplo(a: integer; var b: integer);

begin
a := a + 1;
b := b - 1;
Writeln('a = ',a);
Writeln('b = ',b);
end;

begin {programa principal}

writeln('Digite dois numeros '); readln(X); readln(Y);
writeln;
ProcExemplo(X,Y);
Writeln('acabou o procedimento e X nao mudou = ',X);
Writeln('acabou o procedimento e Y mudou = ',Y);
readln;
end. {fim do programa principal}
Figura XI.7 – Parâmetros de Valor e Referência

Figura XI.8 – Execução do programa “Valor_e_Referencia”

No exemplo anterior, a é um parâmetro de valor, pois não vem precedido da palavra

reservada var. Na Figura XI.8, podemos ver um exemplo de execução do programa, onde
X recebeu o valor 100. Dentro do procedimento o valor de X foi somado em uma unidade
(passou para 101). Mas ao final da execução do procedimento esta alteração não foi
refletida para o programa principal (o valor de X voltou a ser 100).
Por sua vez, b é um parâmetro de referência, pois vem precedido da palavra var. Na
execução ilustrada na Figura XI.8, é possível ver que Y recebeu o valor 90. Dentro do
procedimento ProcExemplo, o valor de Y foi diminuído em uma unidade (passou para
89). Desta vez, ao final da execução do programa a alteração foi, de fato, refletida para o
programa principal: o valor da variável global Y passou a ser 89.

7
 Escola Nacional de Ciências Estatísticas

NOTA TÉCNICA

As alterações nos parâmetros de referência são permanentes porque, internamente, o Pascal

passa para o procedimento não o valor da variável, mas o endereço da variável na memória. Em
outras palavras, a variável usada durante o procedimento e a variável especificada no
procedimento como um parâmetro de referência compartilham um mesmo endereço de
memória RAM. Portanto, uma alteração na primeira se reflete de forma permanente na segunda.

Os parâmetros de valor funcionam de maneira inteiramente diferente. Quando um parâmetro de

valor é especificado em um procedimento, uma cópia temporária da variável é armazenada em
alguma posição livre da memória RAM. Durante o procedimento, somente essa cópia temporária
é usada. Quando o valor do parâmetro é alterado, isso só tem efeito sobre o armazenamento
temporário. A variável fora do procedimento jamais será tocada.

XI.1.4 – Passando um Vetor ou Matriz como Parâmetro

Para que seja possível passar um vetor ou uma matriz como parâmetro para um
procedimento é preciso usar um “macete” da linguagem Pascal: especificar um “tipo-
array”, com o uso do comando type (o mesmo usado para a definição de registros). Veja o
exemplo a seguir:

Exemplo XI.1 - Passagem de vetor como parâmetro

program ParametroVetor;

const N=10;

{esse comando especifica um tipo chamado tVetor

que representa um vetor de inteiros de tamanho 10}
type tVetor = array[1..N] of integer;

{aqui declara-se uma variável chamada VET do tipo tVetor, ou

seja, VET é um vetor de inteiros com 10 posições}
var VET: tVetor;

{procedure Le_Vetor: carrega um vetor do tipo tVetor (passado como

entrada) partir do teclado}
procedure Le_Vetor(var v: tVetor);
var I: integer;
begin
writeln('Digite ', N, ' numeros');
for I:=1 to N do
begin
write('Elemento [',I,']=');
readln(v[I]);
end;
end;

8
 Escola Nacional de Ciências Estatísticas

{procedure Imprime_Vetor: imprime o vetor do tipo tVetor passado como

entrada}
procedure Imprime_Vetor(var v: tVetor);
var I: integer;
begin
writeln('Imprimindo o vetor');
for I:=1 to N do
writeln('Elemento [',I,']=', V[I]);
end;

{programa principal - fica pequenininho}

begin
Le_Vetor(Vet);
Imprime_Vetor(Vet);
readln;
end.

A grande novidade deste programa é o uso do comando type para especificar o

chamado tipo-array. Para usar esse comando, bastam dois passos: (i) inventar um nome
qualquer para o tipo que você está criando (no exemplo, o nome é tVetor) e (ii) informar ao
Pascal o que representa este tipo (no exemplo, é um vetor de inteiros com 10 posições). Daí
em diante, você pode declarar qualquer variável como sendo do tipo tVetor que o Pascal
vai saber que se trata de um vetor de inteiros com tamanho 10.
Essa é, na verdade, a única maneira de passar um vetor ou uma matriz como
parâmetro para um procedimento Pascal, pois ele não aceita a forma mostrada abaixo:

PROCEDURE Le_Vetor(v : ARRAY[1..10] OF integer;);

BEGIN
...
END;

XI.2 Funções

Uma função é um sub-programa que recebe um ou mais parâmetros como

entrada e, como saída, retorna um valor computado. Na Unidade IV o aluno conheceu
algumas das funções matemáticas disponibilizadas pela linguagem Pascal, como SQR
(cálculo do quadrado de um número) e ROUND (arredondamento de um número
fracionário). No entanto, o Pascal disponibiliza diversos outros tipos de função, como as
funções para a manipulação de variáveis string e arquivos texto, por exemplo. Além disso,
o Pascal possibilita com que o programador possa criar as suas próprias funções.
A criação de uma função é similar a criação de um procedimento. Primeiro você
especifica o nome que deseja para a função e define os parâmetro de entrada. A diferença
da função para o procedimento está no fato de que a função sempre retorna um valor. Por
este motivo, quando você criar uma função, será preciso fazer duas coisas:

1. Definir o tipo da função (função inteira, real, string, etc).

9
 Escola Nacional de Ciências Estatísticas

2. Definir um valor para ser retornado (valor de saída) dentro do corpo da

mesma. O valor deve ser do mesmo tipo especificado para o tipo da função.

O exemplo das Figuras XI.9 e XI.10 ilustra como criar uma função

program ExemploFuncao;
var FAT: real;

{definição de uma função do tipo real que calcula o fatorial

de "N" (número inteiro passado como entrada)}
function Fatorial (N: integer): real;
var I:integer;
F:real;
begin
F:=1;
for I:=1 to N do F:=F * I;

Fatorial := F; {essa linha é o retorno da função}

end;

{programa principal}
begin
FAT:=Fatorial(5); {FAT recebe 5!}
writeln(FAT:5:2);

writeln(Fatorial(8):5:2); {imprime 8!}

readln;
end.

Figura XI.9 – Criação de uma Função

Figura XI.10 – Execução do programa “Exemplo Função”

Neste exemplo, a criação da função começa com a seguinte linha:

function Fatorial (N: integer): real;

10
 Escola Nacional de Ciências Estatísticas

Como isto estamos informando ao Pascal que será criada uma função denominada
Fatorial. Esta função possui um parâmetro de entrada, N, do tipo inteiro e retornará um
valor do tipo real 1 (isso é indicado pela palavra real; no final da definição da função).
Analisando o corpo da função Fatorial vemos que as duas primeiras linhas são
responsáveis por obter o fatorial de N e armazenar na variável local F. É importante agora
analisar a última linha dentro do código da função:

Fatorial := F;

Essa linha atribui o valor de F como valor de retorno da função. Toda função
precisa retornar um valor no final! Para fazer a função retornar um determinado valor,
você deve montar um comando de atribuição, onde o nome da função deve ser posto no
lado esquerdo (nesse exemplo, o nome é Fatorial) e o nome do valor a ser retornado
colocado no lado direito (no exemplo, o valor é o que está armazenado na variável local F).

XI.3 Sub-Rotinas Pré-Definidas do Pascal

A linguagem Pascal disponibiliza um conjunto de funções e procedimentos já

prontos para uso (as chamadas sub-rotinas pré-definidas). Esta seção demonstra a forma de
utilizar algumas destas funções e apresenta diversas dicas de programação.

XI.3.1 – Sub-rotinas para a Manipulação de Strings

Função Length

• Funcionamento: Retorna a quantidade de caracteres armazenados em uma variável

string (chamado de “tamanho da string”).
• Tipo da Função: Inteiro.
• Sintaxe (forma de uso) : length(S); {S é uma string}
Exemplo XI.2 - Função Length

program ExemploLength;
var S1, S2: string;
begin
S1 := ‘ENCE‘; S2 := ‘Inconstitucional ‘;

Writeln(S1, ‘ tem ‘, length(S1), ‘ caracteres.‘);

Writeln(S2, ‘ tem ‘, length(S2), ‘ caracteres.‘);
Writeln(‘BRASIL‘, ‘ tem ‘, length(‘BRASIL‘), ‘ caracteres.‘);

readln;
end.

1
Conforme já foi mencionado em outras unidades, em situações práticas, geralmente usamos uma variável
REAL para armazenar o valor do fatorial, pelo fato do tipo REAL suportar valores maiores do que o tipo
INTEGER.

11
 Escola Nacional de Ciências Estatísticas

Função Pos

• Funcionamento: Retorna um inteiro que indica a posição da primeira ocorrência

uma substring dentro de uma string. Por exemplo, na palavra “BOLADA”, a
substring “OLA”, se encontra localizada na posição 2.
• Tipo da Função: Inteiro.
• Sintaxe : pos(Sub,S); {os dois parâmetros de entrada são do tipo string}

Exemplo XI.3 - Função Pos

program ExemploPos;
var S1, S2, S3: string;
begin
S1 := 'MATRIZES';
S2 := 'MARIA FOI AO SUPERMERCADO ';
S3:= 'ER';

Writeln(Pos('ATRIZ',S1)); {retorna 2}
Writeln(Pos('MERCADO',S2)); {retorna 19}
Writeln(Pos('BLABLA',S2)); {retorna 0, pois "blabla" não é uma substring de S2}
Writeln(Pos('BIL','PROBABILIDADE')); {retorna 6}
Writeln(Pos(S3,S2)); {retorna 17, pois é a posição da primeira ocorrência de S3 (‘ER’)
dentro de S2}

readln;
end.

Função Copy

• Funcionamento: A função COPY pode ser utilizada quando desejarmos extrair um

“pedaço” do conteúdo de uma variável string (esse pedaço é chamado de substring).
• Tipo da Função: String
• Sintaxe: copy(S, INICIO, QUANTIDADE).

12
 Escola Nacional de Ciências Estatísticas

Veja que são requeridos três argumentos como entrada para a função. Estes
argumentos são descritos a seguir:

• S: representa a string de onde desejamos pegar um “pedaço”.

• INICIO: representa a posição onde o “pedaço” começa. Valor inteiro.
• QUANTIDADE: representa a quantidade de caracteres que desejamos
extrair. Valor inteiro.

O resultado da função COPY pode ser armazenado em uma variável string ou

utilizado da maneira desejada pelo programador2.

Exemplo XI.4 - Função Copy

program ExemploFuncaoCOPY;
var S: string;
aux1, aux2: string;
begin

{string original}
S := 'ELA FOI PARA BRASILIA';

{aqui eu coloco valores nas variáveis aux1 e aux2

utilizando a função COPY}
aux1 := copy(S,6,2);
aux2 := copy(S,19,3);

writeln('S = ', S); {imprime "ELA FOI PARA BRASÍLIA"}

writeln('aux1 = ', aux1); {imprime "OI"}
writeln('aux2 = ', aux2); {imprime "LIA"}

readln;
end.

2
Outras linguagens de programação também disponibilizam alguma função que
realiza a mesma tarefa que a Copy do Pascal. No entanto o nome da função costuma ser
outro, como Substr (caso das linguagens SQL, SAS e C++) ou MID (Visual Basic).

13
 Escola Nacional de Ciências Estatísticas

Procedure Val

• Funcionamento: Esta procedure é utilizada quando desejamos converter o conteú-

do de uma variável string para um valor numérico. Isso ocorre em muitas situações
práticas. Por exemplo: imagine um programa onde a idade de uma pessoa está arma-
zenada em uma variável string. Considere que se deseja computar o ano de nasci-
mento dessa pessoa. Isso será possível apenas se jogarmos a idade para uma variá-
vel inteira, já que não é possível realizar cálculos matemáticos sobre variáveis
string.

• Sintaxe: Val(S, N, CODE).

Val possui um parâmetro de valor (string S) e dois parâmetros de referência: N (va-

riável real ou inteira) e CODE (variável inteira). A procedure tenta converter S em um va-
lor numérico (Real ou Inteiro, retornado em N). Se a conversão tiver êxito, o Pascal irá atri-
buir a CODE o valor zero. Se não tiver êxito, CODE conterá um inteiro que representa a
posição do caractere que causou o erro.

Exemplo XI.5 - Procedure Val

program ExemploProcedureVal;
var aux1, aux2: string;
CODE1, CODE2: integer;
N1, N2: integer;
begin

aux1 := '1000'; {a string '1000' poderá se transformar no valor 1000

normalmente}

aux2 := 'Maria'; {essa string não poderá ser convertida

para um valor numérico!}

Val(aux1, N1, CODE1); {converte aux1 e joga valor da conversão em N1}

Val(aux2, N2, CODE2); {converte aux2 e joga valor da conversão em N2}

writeln('N1 = ', N1, ' Codigo de erro = ', CODE1); {aqui a conversão
foi OK}

writeln('N2 = ', N2, ' Codigo de erro = ', CODE2); {aqui a conversão
falhou! Maria não
pode virar número, oras!}

readln;
end.

14
 Escola Nacional de Ciências Estatísticas

Procedure Str

• Funcionamento: faz o oposto do procedimento Val. Transforma um valor numérico

em string.

• Sintaxe: Str(N, S).

Val possui um parâmetro de valor (número inteiro ou real N) e um parâmetro de

referência: S (string). O procedimento converte o valor de N para string e armazena em S.

Concatenação de Strings

A concatenação de strings consiste no processo de “juntar” duas strings numa única.

O símbolo “+” é utilizado como operador de concatenação. Considere, por exemplo, que no
seu programa você tenha uma variável A do tipo string, com o valor ‘MATR’ e uma
variável B também do tipo string com o valor armazenado igual a ‘IZES’. Se você fizer A +
B o resultado será ‘MATRIZES’. Veja o exemplo a seguir:

Exemplo XI.6 - Concatenação de Strings

program ExemploConcatenacao;
var aux1, aux2, S: string;

begin

aux1 := 'ESTATISTICA';
aux2 := 'GERAL';

S := aux1 + ' ' + aux2; {concatena aux1, espaço em branco e aux2 e

armazena o resultado em S}
writeln(S);

readln;
end.

String = vetor de caracteres

15
 Escola Nacional de Ciências Estatísticas

Uma variável string é enxergada pelo Pascal como um vetor de caracteres. O

tamanho do vetor é igual ao número caracteres armazenados na string. Analise o exemplo a
seguir para comprovar esta característica do Pascal.
Exemplo XI.7 – Tratando Variável String como Array

program StringEhArray;
var Palavra1, Palavra2: string;
I, Tamanho: integer;

begin

palavra1 := 'MARROCOS';
Tamanho := length(palavra1);

{como uma string é igual a um array de char,

eu posso imprimir letra por letra}
writeln('palavra na ordem certa: ');
for I:=1 to Tamanho do write(Palavra1[I]);

writeln;
{posso percorrer o vetor na ordem inversa também}
writeln('palavra na ordem invertida: ');
for I:= Tamanho downto 1 do write(Palavra1[I]);

writeln;writeln;

palavra2 := 'BOLA';
writeln(palavra2, ' -> palavra original');
{eu posso ainda trocar qualquer caractere de uma string
usando um índice que representa a posição deste caractere na string}
palavra2[2]:='I'; {troquei O por I}
palavra2[3]:='C'; {troquei L por C}
writeln(palavra2, ' -> palavra depois da troca dos caracteres 2 e 3');

readln;

end.

XI.3.2 – Sub-rotinas para a Manipulação de Variáveis CHAR

Funções UpCase e Lowercase

16
 Escola Nacional de Ciências Estatísticas

A função UpCase converte um caractere minúsculo para maiúsculo. Lowercase faz o

oposto: converte um caractere maiúsculo para minúsculo.

As funções só podem ser aplicadas a variáveis do tipo CHAR (ou seja, só conseguem
converter uma letra). A função UpCase não pode ser aplicada diretamente sobre uma string.

Exemplo XI.8 – Convertendo uma palavra para Maiúsculo

program FuncaoUpcase;
var P_minuscula, P_maiuscula: string;
I: integer;
begin

P_minuscula := 'estatistica';
P_maiuscula := p_minuscula;

for I:=1 to length(P_minuscula) do

p_maiuscula[I] := Upcase(P_minuscula[I]);

writeln('em minusculo: ', p_minuscula);

writeln('em maisculo: ', p_maiuscula);

readln;

end.

XI.3.3 – Números Aleatórios

Procedimento Randomize e função Random

Uma das aplicações mais interessante da computação consiste na geração de

seqüências de números aleatórios. A função Random é usada para este propósito. Ela
possui duas formas de utilização:

• Para gerar números aleatórios entre 0 and 1 usa-se a função Random sem
parâmetros. Por exemplo, chamar a função quatro vezes poderia gerar a
série: 0.1467, 0.3838, 0.1193, 0.8930.

• Se desejarmos gerar séries de números inteiros entre 0 e n-1 podemos usar a

fução Random com um parâmetro: Random(n). Com isto, a função
retornará um valor inteiro entre 0 e n-1. Por exemplo, chamar Random(10)
por quatro vezes, poderia gerar a série: 3, 9, 0, 2.

17
 Escola Nacional de Ciências Estatísticas

Um detalhe importantíssimo: a procedure Randomize deve ser utilizada sempre

antes da primeira chamada da função Random. Se isso não for feito o Pascal sempre gerará
séries de números aleatórios idênticas.

Exemplo XI.9 – Números Aleatórios

program DemonstraAleatorios;
var N, I: integer;
begin

{esse programa gera uma série com 100 números aleatórios

entre 1 e 10}

Randomize; {sempre o primeiro passo é chamar Randomize}

for I:=1 to 100 do

begin
N := Random(10) + 1; {gera um aleatório entre 0 e 9 e soma 1}
writeln(N); {imprime o aleatório gerado}
end;

readln;

end.

XI.4 Bibliotecas de Sub-Rotinas

Existem algumas sub-rotinas do Pascal que estão armazenadas em bibliotecas. Para

que você possa utilizar estas sub-rotinas, é preciso incluir uma chamada para estas

18
 Escola Nacional de Ciências Estatísticas

bibliotecas, através do comando uses. Dentre as bibliotecas disponibilizadas pelo Pascal

encontram-se:

o crt : diversas sub-rotinas para saída de dados

o graph: sub-rotinas para a elaboração de gráficos.
o dos : sub-rotinas para a troca de informações com o sistema operacional.

Embora o assunto criação e utilização de bibliotecas seja muito interessante, ele não
será abordado neste curso, por não se tratar de um tema introdutório a programação.

XI.5 Comentários Finais

As sub-rotinas são utilizadas com o intuito principal de permitir a modularização de

um programa, o que significa dividir um programa em pequenas partes. Cada parte deve
executar uma ação específica e pode ser desenvolvida e testada de forma independente.
Quando se tem certeza de que uma sub-rotina está funcionando de maneira correta, ela
pode ser integrada ao programa principal. Na prática é impossível desenvolver um sistema
complexo sem fazer a divisão do código em sub-rotinas distintas.

Exercícios Propostos

(1) Faça um programa que pergunte o nome de uma pessoa via teclado. Em seguida
determine se o nome digitado começa com uma vogal.

(2) Faça um programa que leia uma palavra com tamanho mínimo de 5 e máximo de 15
letras numa variável chamada P1 (o sistema não deve aceitar palavras fora destas
especificações). Em seguida gere uma variável P2 da seguinte forma: ela deve conter as
duas primeiras e as duas últimas letras de P1 concatenadas. Exemplos:

P1 = “ESTATÍSTICA” P2 = “ESTA”
P1 = “MATEMATICA” P2 = “MACA”
P1 = “GOOGLE” P2 = “GOLE”

(3) Faça um programa que leia 5 palavras do teclado e armazene cada uma delas em um
vetor de 5 posições. A seguir calcule e imprima as seguintes informações:

- A quantidade de palavras que terminam com a letra “a”.

- A soma do tamanho de todas as palavras armazenadas no vetor.

(4) Construa o seguinte jogo utilizando a linguagem Pascal: o computador deve sortear um
número entre 1 e 15 - use os comandos Randomize e Random(15) + 1 - e armazenar este
número em uma variável (sem mostrar para o usuário).

19
 Escola Nacional de Ciências Estatísticas

Em seguida ele deve pedir para o usuário adivinhar o número sorteado. O computador deve
dar 3 chances para o usuário acertar. Se o usuário errar na primeira e na segunda chances, o
computador deve dar uma dica para o usuário. Essa dica consiste em indicar se o número
digitado é maior ou menor do que o número que foi sorteado pelo computador.

(5)Considere a seguinte situação: um sistema que receba a matrícula dos alunos de uma
universidade que se inscreveram para realizar a disciplina optativa DATA MINING e que
depois compute algumas estatísticas. Nesta universidade hipotética a matrícula dos alunos é
uma string que possui 8 dígitos em um formato padronizado, conforme ilustra o seguinte
exemplo: M2007001.
Toda matrícula começa com a letra “M”, seguida de quatro dígitos que indicam o
ano em que o aluno ingressou na universidade (ex: 2007). Já os últimos três dígitos da
matrícula, indicam a posição do aluno no vestibular para o seu curso (se for “001”, isso
significa que ele foi o primeiro colocado. Se for “045”, significa que foi o quadragésimo
quinto e assim por diante). Observe mais alguns exemplos:

• M2006002: esse aluno ingressou na universidade em 2006 e obteve a

segunda colocação no vestibular para o seu curso.

• M1999101: esse aluno ingressou na universidade no ano de 1999 e obteve a

centésima primeira colocação no vestibular.

• M2005012: aluno que ingressou em 2005 e foi o décimo-segundo colocado

no vestibular.

Implemente um programa que receba 20 matrículas como entrada (via teclado) e

armazene em um vetor de 20 posições do tipo string[8]. Em seguida calcule e imprima as
seguintes estatísticas:

• A porcentagem de alunos inscritos no curso de DATA MINING que

ingressaram na universidade no ano de 2007.

• A porcentagem de alunos inscritos no curso de DATA MINING que

ingressaram em outro ano, diferente de 2007.

• A quantidade de alunos inscritos no curso, que obtiveram classificação no

vestibular entre o primeiro e o décimo lugar.

20