Baixe Lógica de Programação e outras Notas de estudo em PDF para Informática, somente na Docsity!
Silvoney Fernandes da Silva [email protected]
Índice
1. Variáveis Compostas Homogêneas......................................................................................................................
1.1 Variáveis Indexadas Uni Dimensionais(Vetores)............................................................................................ 1.1.1 Exercícios 10:......................................................................................................................................... 5
1.2 Variáveis Indexadas Bidimensionais(Matrizes).............................................................................................. 1.2.1 Exercícios 11:......................................................................................................................................... 9
- Tipo Record.....................................................................................................................................................
- 2.1.1 Exercícios 1 :........................................................................................................................................
- Tipos Definidos Pelo Usuário e Constantes......................................................................................................
- 3.1 Tipos Definidos Pelo Usuário.......................................................................................................................
- 3.1.1 Exercícios 2 :........................................................................................................................................
- 3.2 Constantes.....................................................................................................................................................
- 3.2.1 Exercícios 3 :........................................................................................................................................
- Sub-Rotinas.....................................................................................................................................................
- 4.1 Procedure.....................................................................................................................................................
- 4.1.1 Exercícios 4 :........................................................................................................................................
- 4.2 Variáveis Globais e Locais...........................................................................................................................
- 4.2.1 Exercícios 5 :........................................................................................................................................
- Passagem de Parâmetros...................................................................................................................................
- 5.1.1 Exercícios 6 :........................................................................................................................................
- .1.2 Exercícios 7 :........................................................................................................................................
- Function.....................................................................................................................................................
- 6.1.1 Exercícios 8 :........................................................................................................................................
- Recursividade.....................................................................................................................................................
- 7.1.1 Exercícios 8 :........................................................................................................................................
- Unit.....................................................................................................................................................
- 8.1.1 Exercícios 9 :........................................................................................................................................
- Arquivos.....................................................................................................................................................
- 9.1 Arquivos FILE...............................................................................................................................................
- 9.1.1 Exercícios 10 :......................................................................................................................................
- 9.2 Arquivos TEXT..............................................................................................................................................
- .3 Sub-Rotinas para Tratamento de Arquivos TEXT.........................................................................................
- 9.3.1 Exercícios 11 :......................................................................................................................................
- Alocação Dinâmica.........................................................................................................................................
- 10.1 Introdução.....................................................................................................................................................
- .2 Definição de Pointers...................................................................................................................................
- .3 Rotinas para Alocação de Memória:............................................................................................................
- .4 Atribuição de Valores....................................................................................................................................
- 10.4.1 Exercícios:............................................................................................................................................
- Lista Simplesmente Encadeada.....................................................................................................................
- 11.1 Definição.....................................................................................................................................................
- .2 Criando Listas na Memória..........................................................................................................................
- 11.2.1 Exercícios:............................................................................................................................................
- Lista Duplamente Encadeada........................................................................................................................
- 12.1.1 Exercícios:............................................................................................................................................
b) Os valores “INICIOV ” e “FIMV” correspondem aos índices inicial e final
c ) Uma variável indexada pode ser apenas de um tipo de dado
Exemplo Definir uma variável indexada como sendo do tipo REAL, sendo que a mesma deverá corresponder a 10
posições de memória.
ALGORITMO Exemplo
VARIÁVEIS
Vet : VETOR [ 1 : 10 ] OF REAL
INICIO
< Comandos>
FIM
Em pascal:
PROGRAM Exemplo;
VAR
Vet : ARRAY [1.. 10] OF REAL;
BEGIN
< Comandos>;
END.
No Exemplo acima , após a definição da variável, a memória estará como mostrado no esquema abaixo :
Vet
Os Valores numéricos apresentados acima correspondem aos índices da variável.
B ) Atribuição
< Nome>[<Índice>] Valor;
LEIA (< Nome>[<Índice>]);
Em pascal:
< Nome>[<Índice>]: = Valor;
READ ([<Índice>]);
Exemplo: ALGORITMO Atribui VARIÁVEIS
Nomes : VETOR [1 : 20 ] DE CADEIA
i : INTEIRO
BEGIN
Nomes [1] ‘ João da Silva’
PARA i 2 ATE 20, PASSO 1, FACA
LEIA( Nomes[ i ])
FIM PARA
FIM
Em pascal:
PROGRAM Atribui ;
VAR
Nomes : ARRAY [ 1..20] OF STRING;
i : INTEGER;
BEGIN
Nomes [1]: =‘ João da Silva’ ;
FOR i: = 2 TO 20 DO
READ (Nomes [i ]);
END.
1.1.1 Exercícios 10:
- Faça um algoritmo que leia, via teclado, 200 valores do tipo inteiro e os guarde na memória.
) Amplie o exercício anterior emitindo um relatório com todos os números pares que você leu.
) Faça um algoritmo que determine qual o menor valor existente no vetor do exercício número 1.
) Faça um algoritmo que determine qual o maior valor existente no vetor do exercício número 1.
) Faça um algoritmo que imprima quantos dos valores do exercício número 1 são maiores que a média desses valores.
) Faça um algoritmo que leia 10 nomes e os guarde na memória.
) Amplie o exercício 6 imprimindo o menor Nome do vetor
) Amplie o exercício 6 imprimindo o maior Nome do vetor
) Faça um algoritmo que leia 20 palavras, e após a leitura, realiza um processo qualquer que inverta os caracteres de cada uma das palavras.
) Faça um algoritmo que leia 10 nomes e os guarde na memória. Após a leitura, emita um relatório com todos os nomes que são palindromes. Uma palavra palindrome é aquela que a sua leitura é a mesma da esquerda para a direita e vice versa. Exemplo: ARARA, ANA, etc.
) Faça um algoritmo que leia, Nome idade e sexo de N pessoas. Após a leitura faça: a) Imprima o Nome, idade e sexo das pessoas cuja idade seja maior que a idade da primeira pessoa. b) Imprima o Nome e idade de todas as mulheres. c) Imprima o Nome dos homens menores de 21 anos.
) Faça uma algoritmo para ler 20 valores e que imprima os que são maiores que a média dos valores.
) Faça um algoritmo que leia Nome e notas ( total de 12 ) de um conjunto indeterminado de alunos de um colégio. Após a leitura faça: a) Imprima o Nome e a média dos alunos aprovados ( Média >= 7.0 ). b) Imprima o Nome e a média dos alunos em Recuperação ( 5.0 >= Média < 7.0 ). c) Imprima o Nome e a média dos alunos reprovados ( Média < 5.0 ). d) Imprima o percentual de alunos aprovados. e) Imprima o percentual de alunos reprovados.
) Dado Nome e salário de 10 funcionários faça: a) Imprima o Nome e o salário dos funcionários que ganham mais de R$ 500, b) Para os funcionários que ganham menos de R$ 200,00 conceda um aumento de 20%. Imprima Nome e o novo salário destes funcionários aumentados
) Um teste composto por 10 questões foi proposto numa classe de n alunos. Cada questão admite as alternativas identificadas pelas letras A, B, C, D e E. Para cada aluno tem-se o registro contendo o seu nome e as suas respostas. Sendo dado o gabarito das questões faça um algoritmo que: a) Escreva uma relação contendo o nome e o número de acertos de cada aluno; b) Determine quantos alunos acertaram as questões 1 e 2 e tiveram 7 acertos; c) Escreva o nome do aluno, que obteve a melhor nota e pior nota;
) Faça um algoritmo para ler 50 valores inteiros. Após imprima tais valores ordenados crescentemente.
) Continuando o exercício anterior, emita um relatório com os valores ordenados decrescentemente.
) Faça um algoritmo que leia 10 valores numéricos inteiros. Após a leitura emita um relatório com cada valor diferente e o número de vezes que o mesmo apareceu no vetor.
) Dado uma ralação de N nomes, faça um algoritmo que verifique se uma determinada pessoa está neste vetor. O Nome da pessoa a ser pesquisada deverá ser lido, bem como os nomes a serem colocados no vetor.
Dado uma frase, faça um algoritmo que determine qual a consoante mais utilizada.
Empregado mais recente: 4631.
) Fazer um algoritmo que: a) leia uma variável indexada A com 30 valores reais; b) leia uma outra variável indexada B com 30 valores reais; c) leia o valor de uma variável X; d) verifique qual o elemento de A é igual a X; e) escreva o elemento de B de posição correspondente à do elemento A igual a X;
) Fazer um programa que: a) leia o valor de M (M<=30) e os valores de uma variável indexada A; b) leia o valor de N (N<=20) e os valores de uma variável indexada B; c) determine o conjunto C = A B (união de A com B), onde C não deverá conter elementos repetidos (A e B não contém elementos repetidos); d) escreva os elementos contidos em A, B e C;
) Intercalação é o processo utilizado para construir uma tabela ordenada, de tamanho n +m, a partir de duas tabelas já ordenadas de tamanhos n e m. Por exemplo, a partir das tabelas:
A= 1
e
B= 2
construímos a tabela
C= 1
Fazer um algoritmo que: a) leia NA, número de elementos do conjunto A (NA<=100); b) leia, em seguida, os elementos do conjunto A; c) leia, logo após o valor de NB, número de elementos do conjunto B (NB<=100); d) leia, finalmente, os elementos do conjunto B; e) crie e imprima um conjunto C, ordenado, de tamanho NA+NB, a partir dos conjuntos originais A e B.
Observação:
. Considerar os elementos de A e B como inteiros.
) Para cada nota de compra , tem-se o Nome do produto comprado, o valor e o imposto. Faça um algoritmo que escreva Nome, valor e imposto de cada produto. Bem como o valor total bruto, o imposto total cobrado e o valor total líquido de todas as notas. Considere 500 notas
- Uma empresa deseja fazer um levantamento do seu estoque. Para isto possui para cada tipo de produto, o seu Nome, o valor unitário e a sua quantidade em estoque. A empresa deseja emitir um relatório contendo, o Nome, quantidade, valor, unitário e o saldo ( valor total ) em estoque de cada tipo de produto. Ao final deseja-se saber quantos tipos de produtos existem em estoque e o saldo de todos os produtos.
) Faça um algoritmo para ler um vetor X de tamanho N de números inteiro. Após a leitura classifique os números, colocando em um vetor P somente os números pares e em um vetor I os impares. Após isso liste os três vetores.
1.1 Variáveis Indexadas Bidimensionais(Matrizes)
Também conhecida por “Matriz”. Uma variável Bidimencional , como o próprio Nome já indica, possui
duas dimensões, sendo ser possível definir variáveis com quaisquer tipo de dados validos do Pascal.
a11 a
A = a21 a
a31 a
Matriz A 3x2 (Linha x Coluna)
a ) Definição :
ALGORITMO Define VARIÁVEIS : MATRIZ [I : J, L:M] DE INICIO FIM
Em pascal:
PROGRAM Define;
VAR
: ARRAY [I..J, L..M] OF ; BEGIN
< Comandos>;
END.
Exemplo Definir uma variável indexada bidemensional para armazenar os dados de uma matriz 4 por 4 de números do tipo REAL, sendo que a mesma deverá corresponder no total a 16 posições de memória.
ALGORITMO Exemplo; VARIÁVEIS MAT : MATRIZ [1:4,1:4] DE REAL INICIO FIM Em pascal: PROGRAM Exemplo; VAR MAT: ARRAY [1..4,1..4] OF REAL; BEGIN ;
END.
No Exemplo acima , após a definição da variável, a memória estará como mostrado no esquema abaixo :
MAT
Os Valores numéricos apresentados acima correspondem aos índices da variável.
B ) Atribuição
< Nome>[<Índice>,<Índice>] Valor;
LEIA (< Nome>[<Índice>,< Índice>]);
Em pascal:
Total
2. Tipo Record
Os tipos de dados que são mais comumente usados, e que foram vistos com maior ênfase em programação I, são :
- WORD
- INTEGER
- REAL
- BYTE
- STRING
- CHAR
- ARRAY
- BOOLEAN
Uma outra forma de definir uma variável em Pascal, é através do tipo RECORD. Esse tipo é diferente das demais formas de definir variáveis, porque permite que uma variável armazene valores de diversos tipos diferentes. Exemplo : Imagine que fosse desejado armazenar informações de uma pessoa, tais como: Nome, Idade, Altura, Sexo, Número de Dependentes, Profissão. Na forma tradicional, seria necessário definir uma variável para cada tipo de informação, ou seja:
VAR Nome : STRING; Idade : BYTE; Altura : REAL; Sexo : CHAR; NumDep : BYTE; Profissão : STRING;
Utilizando o tipo RECORD, a definição seria a seguinte:
VAR
Pessoa : RECORD Nome : STRING; Idade : BYTE; Altura : REAL; Sexo : CHAR; NumDep : BYTE; Profissão : STRING; END;
Ao definir uma variável como sendo do tipo RECORD, devemos definir, também quais serão as partes componentes desta variável(Nome, Idade, Altura , Sexo, NumDep e Profissão), junto com o seu tipo. Quando estamos trabalhando com RECORD, as partes componentes do mesmo recebem um Nome próprio, o qual é conhecido como “campo “. Desta forma, uma variável RECORD pode ter campos de qualquer tipo válido do Pascal, sendo permitido inclusive que um RECORD seja definido dentro do outro, ou como parte de um ARRAY.
Continuando o Exemplo, caso desejarmos atribuir um valor a variável Pessoa, devemos fazê-lo da seguinte forma:
Algoritmo Pessoa.idade 45
Pascal
Pessoa.idade : = 45
O uso do “.” indica que esta variável possui campos, e que “Idade” é um deles. É importante lembrar que as operações realizadas sobre uma variável RECORD, são as mesmas de uma variável “comum”, a única diferença que devemos indicar o Nome da variável, seguido de um ponto(.), seguido do Nome do campo. É possível atribuir o conteúdo de uma variável RECORD para outra variável, de mesmo tipo, da mesma forma que é feito como as outras variáveis do Pascal.
Exemplo: Caso duas variáveis, digamos A e B sejam definidas como sendo RECORDs, e caso seja desejado passar o conteúdo, isto é os valores existentes nos campos, a variável A para a variável B, bastará realizar a seguinte atribuição:
Algoritmo AB
Pascal A: =B
1.1.1 Exercícios 1 :
- Definir um RECORD tendo os seguintes campos: Nome, Semestre, Sala, Curso, Notas(total de seis)
- Faça um algoritmo para ler as informações, descritas acima
- (^) Ampliar a definição anterior, acrescentando a definição de um outro campo(Endereço) que será também um RECORD, o qual terá os seguintes campos: Rua, Bairro, Cidade, Estado, CEP
- Faça um algoritmo para ler as informações de um aluno, junto com o endereço descrito acima
- Defina um ARRAY de alunos, os campos serão os mesmos descritos nos itens anteriores
- Faça um algoritmo para ler as informações de n alunos
- Ordene crescentemente pelo Nome, os alunos
3. Tipos Definidos Pelo Usuário e Constantes
3.1 Tipos Definidos Pelo Usuário
O Pascal possui vários tipos pré-definidos, como INTEGER, WORD, REAL etc, mas além destes tipos básicos, existe a possibilidade de o usuário definir seus próprios tipos de dados. Para isto, é necessário o uso da palavra reservada TYPE, a qual indica que um novo tipo será criado.
Exemplo : Imagine que seja desejado criar um tipo matriz 4X4, sendo que logo em seguida este novo tipo será usado para definir uma variável como sendo deste tipo. P ara isto deverá ser usada a seguinte definição:
TYPE
Matriz = ARRAY[1..4,1..4] OF INTEGER VAR Mat : Matriz
O Pascal permite a definição de tipos usando qualquer um dos tipos pré-definidos, ou até mesmo utilizando tipos definidos pelo usuário
3.1.1 Exercícios 2 :
- Usando a definição para aluno apresentada no exercício da secção anterior, crie um tipo de dado para alunos e em seguida defina uma variável como sendo um ARRAY deste tipo. A título de ilustração, defina o RECORD do campo endereço, como sendo também um tipo . Defina um tipo de dado chamado funcionário, o qual deverá ter o seguinte layout:
Nome Endereço: Rua Número
Pascal IF Tecla = SetaParaBaixo THEN BEGIN ; END;
A forma de se declarar uma constante é através do uso da palavra reservada CONST. Exemplo : Declarar uma constante que representa o valor da seta para baixo, do teclado do PC.
Algoritmo CONSTANTE SetaParaBaixo=CHR(24) INICIO FIM
Pascal CONST SetaParaBaixo=CHR(24) BEGIN ; END
Um outro uso muito útil de constantes é o de definir o tamanho de um ARRAY (VETOR) e o escopo dos laços de repetição, como FOR DO (PARA FAÇA0 , WHILE DO (ENQUANTO FAÇA) e REPEAT UNTIL (REPITA ATÉ).
Algoritmo ALGORITMO Teste CONSTATE TotalLinhas = 10 TotalColunas = 20 TIPO matriz = VETOR[ 1..totallinhas, 1..totalcolunas] DE INTEIRO VARIAVEIS Mat : matriz; lin,col : BYTE; INICIO PARA lin DE 1 ATE totallinhas FAÇA PARA col DE 1 ATE totalcolunas FAÇA LEIA(Mat[lin,col]) FIM PARA FIM PARA FIM
Pascal PROGRAM Teste; CONST TotalLinhas = 10; TotalColunas = 20; TYPE matriz = ARRAY[ 1..totallinhas, 1 ..totalcolunas] OF INTEGER;
VAR
Mat : matriz; lin,col : BYTE; BEGIN FOR lin : = 1 TO totallinhas DO BEGIN FOR col: = 1 TO totalcolunas DO BEGIN READ(mat[lin,col]);
END;
END;
END.
3.1.1 Exercícios 3 :
- Faça um algoritmo para definir constantes representando os códigos das teclas como HOME, END, ESC etc do teclado do PC.
- Faça um algoritmo para declarar constantes que representem as seqüências de caracteres necessários para programar uma impressora de modo a imprimir diversas qualidades como expandido, qualidade carta , condensado, etc. Para isto será necessário o uso do manual de sua impressora , na parte relacionada a programação de impressora.
- Faça um programa para definir constantes que representem as diversas cores/tonalidades que o vídeo do PC possa operar em modo texto, tanto para cor de fundo(bakcground) , como para cor das letras(foreground).
- Faça um algoritmo que defina constantes para construção de molduras. Uma moldura é uma área retangular cercada por caracteres específicos da tabela ASCII. As molduras podem ser por Exemplo, simples , duplas, sombreadas, etc. A tabela ASCII tem uma boa variedade de caracteres específicos para este fim, só depende da imaginação de cada um.
4. Sub-Rotinas
Um matemático uma vez disse que um grande problema se resolve dividindo-o em pequenas partes e resolvendo tais partes em separado. Estes dizeres servem também para a construção de programas. Os profissionais de informática quando necessitam construir um grande sistema, o fazem, dividindo tal programa em partes, sendo então desenvolvido cada parte em separado, mais tarde, tais partes serão acopladas para formar o sistema. Estas partes são conhecidas por vários nomes. Nós adotaremos uma destas nomenclaturas: sub-Rotinas. Podemos dar um conceito simples de sub-Rotina dizendo ser um pedaço de código computacional que executa uma Função bem definida, sendo que esta sub-Rotina pode ser utilizadas várias vezes no algoritmo. Neste curso iremos tratar de dois tipos de sub-Rotinas: PROCEDURE e FUNCTION.
4.1 Procedure
Sintaxe :
Algoritmo PROCEDURE [(parâmetros)] <definições> INICIO FIM
Pascal PROCEDURE [(parâmetros)] <definições> BEGIN ; END;
Uma “PROCEDURE”, é um tipo de sub-Rotina que é ativada através da colocação de seu Nome em alguma parte do programa. Desta forma, assim que o Nome de uma “PROCEDURE”é encontrado, ocorre um desvio no programa, para que os comandos da sub-Rotina sejam executados. Ao término da sub-Rotina, a execução retornará ao ponto subsequente a chamada da “Pocedure”. Exemplo :
Algoritmo ALGORITMO Teste VARIAVEIS
ESCREVA (Nome) FIM
Pascal PROGRAM Teste; VAR Nome : STRING[80]; (variável global) PROCEDURE Setanome; BEGIN READ(Nome); END;
BEGIN Setanome; WRITE(Nome); END
No Exemplo acima, a variável “Nome” , por ser definida como global, pode ser manipulada dentro de qualquer ponto do programa, sendo que qualquer mudança no seu conteúdo, será visível nas demais partes da Rotina. Damos o Nome de variáveis locais às variáveis que são declaradas dentro de uma sub-Rotina, sendo que as mesmas só podem ser manipuladas dentro da sub-Rotina que as declarou, não sendo visíveis em nenhuma outra parte do programa. Exemplo :
Algoritmo ALGORITMO Teste PROCEDURE EscreveNoVídeo VARIAVEIS Número, N : INTEIRO INICIO LEIA (N) PARA número DE 1 ATE N FACA ESCREVA (Número) FIM PARA FIM
INICIO EscreveNoVídeo FIM
Pascal PROGRAM Teste; PROCEDURE EscreveNoVídeo; VAR Número, N : INTEGER; BEGIN READ(N); FOR número : = 1 TO N DO BEGIN WRITE(Número); END; END;
BEGIN EscreveNoVídeo; END;
Obs: É possível definir variáveis globais e locais com o mesmo Nome, sendo qualquer mudança no conteúdo da variável local não afetará o conteúdo da variável global. Exemplo :
Algoritmo ALGORITMO Teste VARIAVEL
Nome : STRING
PROCEDURE Setanome INICIO LEIA (Nome) FIM
PROCEDURE Mudança VARIAVEIS Nome : STRING INICIO LEIA (Nome) FIM
INICIO Setanome ESCREVA (Nome) mudança ESCREVA (Nome) FIM
Pascal PROGRAM Teste; VAR Nome : STRING; PROCEDURE Setanome; BEGIN READ(Nome); END; PROCEDURE Mudança; VAR Nome : STRING; BEGIN READ(Nome); END;
BEGIN
Setanome; WRITE(Nome); mudança; WRITE(Nome); END;
No Exemplo acima, a variável global “Nome” e a variável local “Nome” representam posições de memória totalmente diferentes, logo, qualquer mudança no conteúdo da variável local, não afetará o conteúdo da variável global.
4.1.1 Exercícios 5 :
1 - Faça uma “PROCEDURE” para calcular A elevado a um expoente B.
- Faça uma “PROCEDURE” para calcular o fatorial de um número X qualquer.
- Faça um algoritmo para calcular a seguinte expressão matemática:
Y
X X X X X nX
n
n
- Faça uma PROCEDURE que informe se uma STRING qualquer é palíndrome.
- Faça um algoritmo que leia um vetor de números inteiros. Após, emita um relatório com cada número diferente, e o número de vezes que o mesmo apareceu repetido no vetor.
- Faça um algoritmo para: 10 Ler as informações de n pessoas : Nome, Idade, sexo, altura, peso e endereço(Rua, Número, Bairro, Cidade, Estado), armazenando-as em um vetor. O valor n deverá ser lido.
VAR
Número : INTEGER; Funcionário : STRING;
PROCEDURE EscreveNome(N : INTEGER; Nome : STRING); VAR I : INTEGER; BEGIN FOR i : = 1 TO n DO BEGIN WRITE(Nome); END; END;
BEGIN READ(Número, Funcionário); EscreveNome(Número, Funcionário); END.
Obs: Os números dados aos parâmetros não necessitam serem iguais as variáveis passadas para sub- Rotina. No Exemplo acima, o valor contida em “Número” será passado para o parâmetro “N”, da mesma forma que o valor contido na variável “Funcionário” será passada para o parâmetro “Nome”. Note que os nomes são diferentes.
4.1.1 Exercícios 6 :
1 - Faça um algoritmo para calcular N!
- Faça um algoritmo para calcular A b
- Faça um algoritmo para calcular a seguinte expressão até o n-ésimo:
Y = X - X^2 + X^3 - X^4 + X^5 - ...
a) Passagem de Parâmetros por Valor Qualquer alteração no conteúdo de um parâmetro, dentro de uma sub-Rotina, não será refletido no programa chamado.
Exemplo :
Algoritmo ALGORITMO Teste VARIAVEIS X : INTEIRO PROCEDURE PorValor(A : INTEIRO) INICIO A 5 FIM
INICIO X 10 PorValor (X) ESCREVA (X) FIM
Pascal PROGRAM Teste; VAR X : INTEGER; PROCEDURE PorValor(A : INTEGER); BEGIN A : = 5; END;
BEGIN
X : = 10;
PorValor(X);
WRITE(X);
END.
No Exemplo acima, o conteúdo da variável “X” não será alterado após o retorno ao programa principal.
b) Passagem do Parâmetros por Referência Quando a alteração no conteúdo de um parâmetro, dentro de uma sub-Rotina, se reflete no programa chamador. Os parâmetros a serem passados por referência deverão ter, na definição da sub-Rotina, colocado na frente do Nome do parâmetro, a palavra “VAR”. Exemplo :
Algoritmo ALGORITMO Teste VARIAVEIS X : INTEIRO PROCEDURE PorReferência(VARIAVEL A: INTEIRO) INICIO A 5 FIM
INICIO X 10 PorReferência(X) ESCREVA (X) FIM
Pascal PROGRAM Teste; VAR X : INTEGER; PROCEDURE PorReferência(VAR A: INTEGER); BEGIN A : = 5; END;
BEGIN
X : = 10;
PorReferência(X); WRITE(X); END.
No Exemplo acima , o conteúdo da variável “X” será alterado após o retorno ao programa principal
c) O problema dos tipos na definição de parâmetros O Pascal, a princípio, aceita somente que sejam definidos parâmetros com os seguintes tipos : INTEGER, REAL, BYTE, WORD, BOOLEAN, CHAR, STRING e os outros tipos ditos simples. Desta forma, tipos como ARRAY, RECORD e STRING com tamanho definido pelo usuário, não são aceitos. Acontece que existe uma forma de fazer o Pascal aceitar qualquer tipo de dados na definição de parâmetros, através da definição de tipos pelo usuário, ou seja, criar tipos através do comando TYPE. Exemplo :
Algoritmo ALGORITMO Teste CONSTANTE Máximo = 50 TIPO Vetor = VETOR[1..Máximo] DE INTEIRO Registro =RECORD descrição : STRING cor : STRING Quant : BYTE FIM VARIAVEL Vet : vetor
