6_Array e Rotinas

Prévia do material em texto

Estrutura de Arrays e subprogramação
Primeiro vamos explicar a estrutura de array. A estrutura de array ou agregados homogêneos, como diz a segunda definição, é uma variável que agrega vários valores de mesmo tipo e que pode ser referenciado através de um índice indicando sua posição dentro da área reservada para aquela variável.
Imagine um algoritmo para ler o nome de 10 cidades e respectivas temperaturas médias do ano anterior em Celsius, deseja converter para Kelvin, e escrever os valores lidos e calculados. Teríamos então um algoritmo mais ou menos assim:
Início
Defina ncidade caracter
Defina tempc, tempk real
Defina i inteiro
Para i de 1 até 10 passo 1 faça
	Leia ncidade, tempc
	tempk ( tempc + 273
	Escreva ncidade, tempc, tempk
Fim-para
Fim
Desta forma eu consigo realizar o procedimento pedido no enunciado sem problemas.
Veja como fica a tabela de símbolos na memória após definirmos as variáveis simples.
	Variável
	Tipo
	Valor
	ncidade
	Caracter
	
	tempc
	Real
	
	tempk
	Real
	
	i
	Inteiro
	
Agora vamos transformar este código utilizando array (neste caso um array unidimensional mais conhecido como vetor):
Início
Defina ncidade(10) caracter
Defina tempc(10), tempk(10) real
Defina i inteiro
Para i de 1 até 10 passo 1 faça
	Leia ncidade(i), tempc(i)
	tempk(i) ( tempc(i) + 273
	Escreva ncidade(i), tempc(i), tempk(i)
Fim-para
Fim
A diferença agora com o fato de termos inserido um índice para cada variável é que desta forma, no segundo caso, todos os valores lidos e calculados residem na memória do computador até que o código seja finalizado. O que não aconteceria se utilizarmos variáveis simples.
Assim sendo, podemos entrar com a segunda parte que é a subprogramação.
Antes de entrar propriamente na subprogramação, devemos entender que o código pode ser subdividido mesmo sem utilizar este recurso.
No código utilizado conseguimos notar três processos elementares (leitura, cálculo, e escrita). Estes processos elementares podem ser executados separadamente, pois a partir da leitura das informações das cidades e respectivas temperaturas, todos os outros processos podem ser realizados separadamente.
Veja como fica a tabela de símbolos na memória após definirmos as variáveis como array.
	Variável
	Tipo
	Valor
	
	
	1
	2
	3
	4
	5
	6
	7
	8
	9
	10
	ncidade
	Caracter
	
	
	
	
	
	
	
	
	
	
	tempc
	Real
	
	
	
	
	
	
	
	
	
	
	tempk
	Real
	
	
	
	
	
	
	
	
	
	
	I
	Inteiro
	
Então poderíamos desmembrar o código por processos elementares e escrever da seguinte forma:
Início
Defina ncidade(10) caracter
Defina tempc(10), tempk(10) real
Defina i inteiro
Para i de 1 até 10 passo 1 faça
	Leia ncidade(i), tempc(i)
Fim-para
Para i de 1 até 10 passo 1 faça
	Tempk(i) ( tempc(i) + 273
Fim-para
Para i de 1 até 10 passo 1 faça
	Escreva ncidade(i), tempc(i), tempk(i)
Fim-para
Fim
Então vejamos o que aconteceu. O primeiro bloco de repetição executa a leitura de todos os valores e respectivo armazenamento na tabela de símbolos descrita acima. Repare que como existe o índice, cada valor lido ocupa um espaço determinado apontado por este índice.
Seguindo a lógica chegamos ao segundo bloco de repetição que executa a conversão de cada temperatura lida em Celsius e convertida para Fahrenheit. E por último, a escrita dos valores.
Note que os blocos de repetição não podem ser trocados de posição como não poderiam ser trocados os comandos no código inicial.
Lembre que só é possível converter a temperatura se tiver este valor em memória (que é armazenado após a leitura). E também só é possível escrever os valores se a temperatura em Fahrenheit já tiver sido calculada.
Atente para o seguinte detalhe, o valor da temperatura em graus Celsius está armazenado na memória após a leitura das mesmas em meio externo. Já os valores das temperaturas em graus Kelvin é armazenada através do cálculo dos valores utilizando uma expressão que contém o valor da temperatura em graus Celsius lida.
�
Subprogramação (Rotinas e subrotinas)
Vamos agora desmembrar o código da seguinte forma:
	Para i de 1 até 10 passo 1 faça
	Leia ncidade(i), tempc(i)
Fim-para
	Para i de 1 até 10 passo 1 faça
 Tempk(i) ( tempc(i) + 273
Fim-para
	Para i de 1 até 10 passo 1 faça
 Escreva ncidade(i), tempc(i), tempk(i)
Fim-para
Supondo que cada bloco deve ser um programa independente, cada um deles deveria ter a definição das variáveis usadas individualmente e o fim de cada módulo. Sendo assim, teremos o seguinte:
	Defina ncidade(10) caracter
Defina tempc(10) real
Defina i inteiro
Para i de 1 até 10 passo 1 faça
	Leia ncidade(i), tempc(i)
Fim-para
Fim
	Defina tempc(10), tempk(10) real
Defina i inteiro 
Para i de 1 até 10 passo 1 faça
 tempk(i) ( tempc(i) + 273
Fim-para
Fim
	Defina ncidade(10) caracter
Defina tempc(10), tempk(10) real
Defina i inteiro 
Para i de 1 até 10 passo 1 faça
 Escreva ncidade(i), tempc(i), tempk(i)
Fim-para
Fim
Se aplicarmos a definição de sub-rotinas, teremos os seguintes módulos:
	Subrotina lerdados
 Defina ncidade(10) caracter
 Defina tempc(10) real
 Defina i inteiro
 Para i de 1 até 10 passo 1 faça
 	 Leia ncidade(i), tempc(i)
 Fim-para
Fim
	Subrotina converter
 Defina tempc(10), tempk(10) real
 Defina i inteiro 
 Para i de 1 até 10 passo 1 faça
 tempk(i) ( tempc(i) + 273
 Fim-para
Fim
	Subrotina escrever
 Defina ncidade(10) caracter
 Defina tempc(10), tempfk10) real
 Defina i inteiro 
 Para i de 1 até 10 passo 1 faça
 Escreva ncidade(i), tempc(i), tempk(i)
 Fim-para
Fim
Mas as sub-rotinas sozinhas como estão sendo apresentadas não funcionariam. Existe a necessidade de ditar a ordem em que elas serão executadas. Então, definimos o que chamamos de rotina principal. A partir dela definimos a ordem em que elas serão executadas.
Vejamos então como ficaria a chamada das sub-rotinas na rotina principal para que a execução dos módulos continue atendendo o enunciado que está sendo trabalhado:
Chame lerdados
Chame converter
Chame escrever
Agora precisamos definir as variáveis que transitarão entre os módulos e o programa principal. Lembre que as variáveis só existem enquanto o módulo é executado. Assim, quando a rotina principal executa uma das sub-rotinas, ao término da execução da mesma, o conteúdo das variáveis locais a cada sub-rotina será apagada.
Para que os valores não sejam perdidos após a execução da sub-rotina, especificamos variáveis que serão usadas como parâmetros de passagem de informação das sub-rotinas para o programa principal.
Apenas as variáveis definidas no programa principal são mantidas durante todo o processo.
�
Por isso, precisamos declarar na rotina principal todas as variáveis que serão usadas no processo. Sendo assim teremos além das chamadas, a declaração das variáveis lidas e calculadas:
Início
Defina ncidade(10) caracter
Defina tempc(10), tempk(10) real
Chame lerdados
Chame converter
Chame escrever
Fim
Note que a variável de controle de repetição não foi incluída. Isto porque a mesma só será utilizada dentro dos módulos para a finalidade que expusemos agora.
Agora iremos colocar as variáveis cujos valores serão trocados entre a rotina principal e as sub-rotinas.
Início
Defina ncidade(10) caracter
Defina tempc(10), tempk(10) real
Chame lerdados (ncidade, tempc)
Chame converter (tempc, tempk)
Chame escrever (ncidade, tempc, tempk)
Fim
Subrotina lerdados (ncidade, tempc)
	Defina ncidade(10) caracter
	Defina tempc(10) real
	Defina i inteiro
	Para i de 1 até 10 passo 1 faça
	 	 Leia ncidade(i), tempc(i)
	Fim-para
Fim
Subrotina converter (tempc, tempk)
	Defina tempc(10), tempk(10) real
	Defina i inteiro 
	Para i de 1 até 10 passo 1 faça
	 tempk(i)( tempc(i) + 273
	Fim-para
 Fim
Subrotina escrever (ncidade, tempc, tempk)
	Defina ncidade(10) caracter
	Defina tempc(10), tempk(10) real
	Defina i inteiro 
	Para i de 1 até 10 passo 1 faça
	 Escreva ncidade(i), tempc(i), tempk(i)
	Fim-para
 Fim
Veja que na primeira sub-rotina apenas duas variáveis foram informadas (os valores que devem ser lidos), na segunda sub-rotina outras duas variáveis (o valor usado para conversão e o que será convertido) e por último as três variáveis (pois todos os valores serão escritos).
�
Observação
As variáveis das sub-rotinas não precisam ter o mesmo nome das variáveis da rotina principal. Ao final da execução da sub-rotina, os valores armazenados nas variáveis relacionadas como parâmetros serão levados para as variáveis existentes na rotina principal.
Desta forma eu posso trocar o nome de todas as variáveis existentes nas sub-rotinas. Veja no algoritmo abaixo:
Início
Defina ncidade(10) caracter
Defina tempc(10), tempk(10) real
Chame lerdados (ncidade, tempc)
Chame converter (tempc, tempk)
Chame escrever (ncidade, tempc, tempk)
Fim
Subrotina lerdados (x, y)
	Defina x(10) caracter
	Defina y(10) real
	Defina i inteiro
	Para i de 1 até 10 passo 1 faça
	 	 Leia x(i), y(i)
	Fim-para
Fim
Subrotina converter (x, y)
	Defina x(10), y(10) real
	Defina i inteiro 
	Para i de 1 até 10 passo 1 faça
	 y(i) ( x(i) + 273
	Fim-para
 Fim
Subrotina escrever (x, y, z)
	Defina x(10) caracter
	Defina y(10), z(10) real
	Defina i inteiro 
	Para i de 1 até 10 passo 1 faça
	 Escreva x(i), y(i), z(i)
	Fim-para
 Fim
Então quando acontece a chamada da rotina lerdados na rotina principal, após a execução da mesma, valores serão armazenados nas variáveis x e y. Como os parâmetros indicam uma relação com as variáveis ncidade e tempc, antes da rotina ser encerrada os valores das variáveis serão passadas de x e y locais à rotina “lerdados” para as variáveis globais ncidade e tempc.
Quando a rotina “converter” for executada os valores de tempc serão armazenados na variável x (da rotina “converter”) e que serão usadas para cálculo da variável y. Ao final serão atribuídas à variável tempk.
Note que apesar das rotinas “lerdados” e “converter” possuírem os mesmos nomes de variáveis os dois tem tipos diferentes e são usadas para armazenar valores diferentes em cada instância.
Na rotina “lerdados”, a variável x possui os valores dos nomes das cidades e na rotina “converter” a variável x possui as temperaturas em graus Celsius.
Na rotina “lerdados”, a variável y possui os valores das temperaturas em graus Celsius, e na rotina “converter” a variável y possui os valores das temperaturas em graus Kelvin calculadas. 
�
Agora vejamos o seguinte enunciado:
Fazer um algoritmo para ler 10 valores quaisquer, e criar um vetor apenas com os valores nas posições pares. O algoritmo seria algo parecido com o código abaixo:
	Início
Defina a(10),b(5) real
Chame ler (a)
Chame criar (a, b)
Chame escr1 (a)
Chame escr2 (b)
Fim
Subrotina ler (x)
	Defina x(10) real
	Defina i inteiro
	Para i de 1 até 10 passo 1 faça
	 	 Leia x(i)
	Fim-para
Fim
Subrotina criar (x, y)
	Defina x(10), y(5) real
	Defina i inteiro 
	Para i de 1 até 5 passo 1 faça
	 y(i) ( x(i * 2)
	Fim-para
 Fim
Subrotina escr1 (x)
	Defina y(10) real
	Defina i inteiro 
	Para i de 1 até 10 passo 1 faça
	 Escreva x(i)
	Fim-para
 Fim
Subrotina escr2 (x)
	Defina x(5) real
	Defina i inteiro 
	Para i de 1 até 10 passo 1 faça
	 Escreva x(i)
	Fim-para
 Fim
	Note que existem 2 rotinas de escrita (escr1 e escr2). Isto se deve pelo fato de que a variável definida em cada rotina é de tamanho diferente.
Na rotina escr1 o valor é um array contendo 10 valores e na rotina escr2, o valor é um array contendo 5 valores.
Veja que se o tipo for diferente, a rotina também deveria ser outra.
Detalhe:
Apesar dos arrays terem quantidades diferentes, sempre terá a mesma quantidade dentro de cada um deles (10 no primeiro e 5 no segundo).
�
Vejamos o este outro enunciado:
Fazer um algoritmo para ler 10 valores inteiros, e criar um vetor apenas com os valores pares. O algoritmo seria algo parecido com o código abaixo:
	Início
Defina val(10),valpospar(10), cont inteiro
Chame ler (val)
Chame criar (val, valpospar, cont)
Chame escr1 (val)
Chame escr2 (valpospar, cont)
Fim
Subrotina ler (x)
	Defina i, x(10) inteiro
	Para i de 1 até 10 passo 1 faça
	 	 Leia x(i)
	Fim-para
Fim
Subrotina criar (x, y, k)
	Defina i, k, x(10), y(10) inteiro 
	k ( 0
	Para i de 1 até 10 passo 1 faça
		Se (-1)** x(i) = 1 Então
	 	k ( k + 1
	 	y(k) ( x(i)
	 Fim-se
	Fim-para
 Fim
Subrotina escr1 (x)
	Defina i, x(10) inteiro 
	Para i de 1 até 10 passo 1 faça
	 Escreva x(i)
	Fim-para
 Fim
Subrotina escr2 (x, k)
	Defina i, k, x(5) inteiro 
	Para i de 1 até k passo 1 faça
	 Escreva x(i)
	Fim-para
 Fim
	Veja que a variável lida pode ou não conter valores pares. Se todos forem pares o vetor resultante conterá 10 valores, mas se todos forem ímpares, o vetor resultante não possuirá valores.
Neste caso também existem 2 rotinas de escrita (escr1 e escr2). Isto se deve pelo fato de que a variável definida em cada rotina é de tamanho diferente.
Na rotina escr1 o valor é um array contendo 10 valores e na rotina escr2, o valor é um array contendo no máximo 10 valores (Pode até não possuir valores no vetor resultante caso não haja valores pares no array lido).
�
Suponhamos agora um enunciado para criar um algoritmo onde eu preciso ler 10 valores quaisquer de 3 vetores, sendo que a leitura deva ser feita um vetor por vez. Calcular a soma dos valores dos 3 vetores posição a posição e armazenar o resultado em um novo vetor e no final escrevê-los lado a lado. 
Então teríamos loops independentes para leitura de cada vetor e o algoritmo sem uso sub-rotina ficaria assim: 
Início
Defina a(10), b(10), c(10), result(10) real
Defina i inteiro
Para i de 1 até 10 passo 1 faça
 Leia a(i)
Fim-para
Para i de 1 até 10 passo 1 faça
 Leia b(i)
Fim-para
Para i de 1 até 10 passo 1 faça
 Leia c(i)
Fim-para
Para i de 1 até 10 passo 1 faça
 res(i) ( a(i) + b(i) + c(i)
Fim-para
Para i de 1 até 10 passo 1 faça
 Escreva a(i), b(i), c(i), res(i)
Fim-para
Fim
�
	Colocando o algoritmo com sub-rotina, teríamos algo parecido com a estrutura abaixo:
Início
Defina a(10), b(10), c(10), res(10) real
Chame ler1(a)
Chame ler2(b)
Chame ler3(c)
Chame calc(a, b, c, res)
Chame escr(a, b, c, res)
Fim
Subrotina ler1(x)
 Defina x(10) real
 Defina i inteiro
 Para i de 1 até 10 passo 1 faça
 Leia x(i)
 Fim-para
Fim-Subrotina
Subrotina ler2(x)
 Defina x(10) real
 Defina i inteiro
 Para i de 1 até 10 passo 1 faça
 Leia x(i)
 Fim-para
Fim-Subrotina
Subrotina ler3(x)
 Defina x(10) real
 Defina i inteiro
 Para i de 1 até 10 passo 1 faça
 Leia x(i)
 Fim-para
Fim-Subrotina
Subrotina calc(x,y,z,w)
 Defina x(10), y(10), z(10), w(10) real
 Defina i inteiro
 Para i de 1 até 10 passo 1 faça
 w(i) ( x(i) + y(i) + z(i)
 Fim-para
Fim-Subrotina
Subrotina escr(x, y, z, w)
 Defina x(10), y(10), z(10), w(10) real
 Defina i inteiro
 Para i de 1 até 10 passo 1 faça
 Escreva x(i), y(i), z(i), w(i)
 Fim-para
Fim-Subrotina
	Note que na construção ao lado, as rotinas de leitura dos valores dos três vetores são idênticas, apenas o nome das rotinas são diferentes. 
Agora entramos com a outra vantagem de uso de sub-rotinas que é o reaproveitamento do código:
Início
Defina a(10), b(10), c(10), res(10) real
Chame ler(a)
Chame ler(b)
Chame ler(c)
Chame calc(a, b, c, res)Chame escr(a, b, c, res)
Fim
Subrotina ler(x)
 Defina x(10) real
 Defina i inteiro
 Para i de 1 até 10 passo 1 faça
 Leia x(i)
 Fim-para
Fim-Subrotina
Subrotina calc(x, y, z, w)
 Defina x(10), y(10), z(10), w(10) real
 Defina i inteiro
 Para i de 1 até 10 passo 1 faça
 w(i) ( x(i) + y(i) + z(i)
 Fim-para
Fim-Subrotina
Subrotina escr(x, y, z, w)
 Defina x(10), y(10), z(10), w(10) real
 Defina i inteiro
 Para i de 1 até 10 passo 1 faça
 Escreva x(i), y(i), z(i), w(i)
 Fim-para
Fim-Subrotina
Note que a cada execução da rotina ler, os valores lidos na variável x, são retornados a uma variável diferente. 
A primeira vez para a variável a, a segunda vez para a variável b, e a última vez para a variável c.