8_Metodo_de_Depuracao_de_Erros_Subprograma

Prévia do material em texto

Método de depuração de erros - Teste de Mesa
O método de depuração de erros é executado para uma rotina. Assim, quando executamos o teste de mesa sobre um programa contendo vários subprogramas (rotinas e funções), devemos tratar cada subprograma como um programa independente, ou seja, montar uma estrutura de teste de mesa para cada um deles.
Vejamos como iremos nos comportar para a execução do teste de mesa para o seguinte algoritmo:
	Início
Defina a(5), b(5), c(5) real
Chame lervet(a)
Chame lervet(b)
Chame criavet(a, b, c)
Chame escrvet(a, b, c)
Fim
Subrotina lervet(X)
 Defina x(5) real
 Defina i inteiro
 Para i de 1 até 5 passo 1 faça
 Leia x(i)
 Fim-para
Fim-subrotina
	Subrotina escrvet(X)
 Defina x(5) , y(5), z(5) real
 Defina i inteiro
 Para i de 1 até 5 passo 1 faça
 Escreva x(i), y(i), z(i)
 Fim-para
Fim-subrotina
Subrotina criavet(X)
 Defina x(5), y(5), z(5) real
 Defina i inteiro
 Para i de 1 até 5 passo 1 faça
 z(i) ( x(i) + y(i)
 Fim-para
Fim-subrotina
Note que o algoritmo acima possui 4 rotinas (rotina principal e as sub-rotinas lervet (usada 2 vezes), criavet e escrvet). Note ainda que as sub-rotinas não aparecem na ordem de chamada. 
Lembre-se então que não importa a ordem que as sub-rotinas aparecem, mas a ordem em que elas são chamadas e executadas na rotina principal. 
Começamos então com a execução da rotina principal. Veja como fica o teste de mesa deste módulo:
	a
	b
	c
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
Note que as variáveis a, b, e c são as únicas variáveis existentes na rotina principal. Perceba também que não existem comandos de leitura e / ou escrita além de condicionais.�
Mas então como terei valores nas variáveis?
Simples!!! 
Na rotina principal temos as chamadas para as sub-rotinas. São nelas que ocorrem os procedimentos. Como vimos anteriormente, devemos pensar nas sub-rotinas como execução de algoritmos independentes que executam uma determinada tarefa. Por exemplo, o primeiro comando a ser executado na rotina principal é o comando chame. Este comando remete à execução da sub-rotina lervet. Iremos agora construir o teste de mesa desta sub-rotina. Veja abaixo:
	Entrada
	x
	i
	i≤5
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
Seguindo o que vimos no capítulo de execução de teste de mesa, devemos atentar aos seguintes pontos. A estrutura possui:
Entrada de dados, pois possui pelo menos um comando de leitura
As variáveis usadas são todas as variáveis definidas dentro da sub-rotina (x – variável do tipo array contendo 5 valores, e i – variável simples)
As condicionais existentes dentro da sub-rotina. Neste caso só temos o condicional (i≤5) implícito no comando de repetição incondicional.
Uma vez executado o teste de mesa deste módulo, teremos algo como a visão abaixo:
	Entrada
	x
	i
	i≤5
	2.3
4
-3 
7 
21
	2.3
	1
2
3
4
5
6
	.V.
.V.
.V.
.V.
.V.
.F.
	
	4
	
	
	
	-3
	
	
	
	7
	
	
	
	21
	
	
Neste caso selecionei 5 valores quaisquer para leitura. Uma vez que o array unidimensional de nome x tenha sido preenchido, antes que a sub-rotina seja fechada, os valores armazenados em x serão passadas por parâmetro definido na chamada da sub-rotina. Sendo assim, os valores de x serão passados ao teste de mesa da rotina principal para a variável a.
Veja então como fica o teste de mesa da rotina principal: 
	a
	b
	c
	2.3
	
	
	4
	
	
	-3
	
	
	7
	
	
	21
	
	
�
O mesmo ocorre ao executar novamente a sub-rotina lervet, só que desta vez os valores acumulados na variável x, serão atribuídas à variável b quando do retorno à rotina principal (associação de parâmetros). 
	Entrada
	x
	i
	i≤5
	67
-8
3 
12 
33
	67
	1
2
3
4
5
6
	.V.
.V.
.V.
.V.
.V.
.F.
	
	-8
	
	
	
	3
	
	
	
	12
	
	
	
	33
	
	
O procedimento que usamos para leitura dos valores das variáveis de a e b é o que chamados de reutilização de código. Como as variáveis lidas são de mesmo tipo, gênero, e tamanho, foi possível usar a mesma rotina para leitura dos valores (um por vez).
O teste de mesa para leitura dos valores de b deve aparecer abaixo da leitura dos valores de a como vemos a seguir:
	Entrada
	x
	i
	i≤5
	2.3
4
-3 
7 
21
	2.3
	1
2
3
4
5
6
	.V.
.V.
.V.
.V.
.V.
.F.
	
	4
	
	
	
	-3
	
	
	
	7
	
	
	
	21
	
	
	67
-8
3 
12 
33
	67
	1
2
3
4
5
6
	.V.
.V.
.V.
.V.
.V.
.F.
	
	-8
	
	
	
	3
	
	
	
	12
	
	
	
	33
	
	
Assim que a execução da sub-rotina para leitura dos valores de b termina e retornamos à rotina principal, os valores de x são passados para b e então teremos o seguinte no teste de mesa da rotina principal:
	a
	b
	c
	2.3
	67
	
	4
	-8
	
	-3
	3
	
	7
	12
	
	21
	33
	
O módulo a ser executado na sequência é o criavet. Note que as variáveis usadas como parâmetros para envio /recebimento de valores são respectivamente x, y, e z. Estas variáveis estão relacionadas (na chamada) às variáveis a, b, e c. Logo, ao executarmos a chamada os valores das variáveis a e b serão atribuídos às variáveis x e y.
�
Desta maneira, ao executarmos o módulo criavet, teremos o seguinte teste de mesa:
	x
	y
	z
	i
	i≤5
	2.3
	67
	69.3
	1
2
3
4
5
6
	.V.
.V.
.V.
.V.
.V.
.F.
	4
	-8
	-4
	
	
	-3
	3
	0
	
	
	7
	12
	19
	
	
	21
	33
	54
	
	
Ao retornar À rotina principal os valores acumulados em z serão passados para a memória da seguinte forma:
	a
	b
	C
	2.3
	67
	69.3
	4
	-8
	-4
	-3
	3
	0
	7
	12
	19
	21
	33
	54
Iremos executar então a rotina que é escrvet. Neste caso, todos os valores a serem escritos já existem na memória principal. Eles só serão impressos nesta rotina.
Veja como fica o teste de mesa desta rotina:
	x
	y
	z
	i
	i≤5
	Saída
	2.3
	67
	69.3
	1
2
3
4
5
6
	.V.
.V.
.V.
.V.
.V.
.F.
	2.3 67 69.3
4 -8 -4
-3 3 0
7 12 19
21 33 54
	4
	-8
	-4
	
	
	
	-3
	3
	0
	
	
	
	7
	12
	19
	
	
	
	21
	33
	54
	
	
	
Veja como fica a execução total do teste de mesa do algoritmo proposto:
	Rotina Principal
a
b
c
2.3
67
69.3
4
-8
-4
-3
3
0
7
12
19
21
33
54
	Rotina lervet
Entrada
x
i
i≤5
2.3
4
-3
7 
21
2.3
1
2
3
4
5
6
.V.
.V.
.V.
.V.
.V.
.F.
4
-3
7
21
67
-8
3 
12 
33
67
1
2
3
4
5
6
.V.
.V.
.V.
.V.
.V.
.F.
-8
3
12
33
	Rotina criavet
x
y
z
i
i≤5
2.3
67
69.3
1
2
3
4
5
6
.V.
.V.
.V.
.V.
.V.
.F.
4
-8
-4
-3
3
0
7
12
19
21
33
54
Rotina escrvet
	x
	y
	z
	i
	i≤5
	Saída
	2.3
	67
	69.3
	1
2
3
4
5
6
	.V.
.V.
.V.
.V.
.V.
.F.
	2.3 67 69.3
4 -8 -4
-3 3 0
7 12 19
21 33 54
	4
	-8
	-4
	
	
	
	-3
	3
	0
	
	
	
	7
	12
	19
	
	
	
	21
	33
	54
	
	
	
�
Suponha que ao programa anterior eu queira incluir um novo procedimento para escrever a média de todos os valores do vetor resultante que sejam positivos. O algoritmo então sofreria uma alteração na rotina principal e seria acrescido de uma função para o cálculo desta média. Veja a rotina alterada e a nova função:
Início
Defina a(5), b(5), c(5), media real
Chame lervet(a)
Chame lervet(b)
Chame criavet(a, b, c)
Chame escrvet(a, b, c)
Escreva media(c)
Fim
Função media(x)
 Defina x(5), media real
 Defina i, cont inteiromedia ( 0
 cont ( 0
 Para i de 1 até 5 passo 1 faça
 Se x(i) > 0 Então
 media ( media + x(i)
 cont ( cont + 1
 Fim-se
 Fim-para
 media ( media / cont
Fim-função
Note que o teste de mesa da rotina principal será acrescido desta nova variável (media) e de uma saída de dados que é da escrita desta média. Veja abaixo:
	a
	b
	c
	media
	Saída
	2.3
	67
	69.3
	
	
	4
	-8
	-4
	
	
	-3
	3
	0
	
	
	7
	12
	19
	
	
	21
	33
	54
	
	
Então esta seria a visualização até a execução do comando escreva. Quando o comando de escrita é executado, antes da escrita, a função definida pelo usuário é executada. Veja abaixo:
	x
	media
	cont
	i
	i≤5
	X(i)>0
	69.3
	0
	0
	
	
	
	-4
	
	
	
	
	
	0
	
	
	
	
	
	19
	
	
	
	
	
	54
	
	
	
	
	
Note que os valores do vetor resultante foram trazidos da memória usada pela rotina principal para dentro da memória usada pela função.
O primeiro comando a ser executado é o comando de atribuição do valor da variável media.
O segundo comando a ser executado é o comando de atribuição do valor da variável cont.
A média acumulará os valores positivos, enquanto o cont acumulará quantos foram estes valores. Isto é necessário para o cálculo da média ao final do loop.
�
Imaginemos então a execução do loop até o seu final. Veja abaixo:
	X
	media
	cont
	i
	i≤5
	X(i)>0
	69.3
	0
69.3
88.3
142.3
	0
1
2
3
	1
2
3
4
5
6
	.V.
.V.
.V.
.V.
.V.
.F.
	.V.
.F.
.F.
.V.
.V.
	-4
	
	
	
	
	
	0
	
	
	
	
	
	19
	
	
	
	
	
	54
	
	
	
	
	
O próximo comando a ser executado é o comando de atribuição logo após o Fim-para.
Note que a variável media é utilizada para receber o cálculo da divisão da própria média pelo valor de cont. Esta variável é reutilizada, pois não precisamos da soma dos valores positivos e sim da média. Sendo assim, podemos “perder” este valor sem detrimento do nosso cálculo.
Veja então como fica o teste de mesa após a execução deste comando.
	X
	media
	cont
	i
	i≤5
	X(i)>0
	69.3
	0
69.3
88.3
142.3
47.43
	0
1
2
3
	1
2
3
4
5
6
	.V.
.V.
.V.
.V.
.V.
.F.
	.V.
.F.
.F.
.V.
.V.
	-4
	
	
	
	
	
	0
	
	
	
	
	
	19
	
	
	
	
	
	54
	
	
	
	
	
Antes do encerramento da função o valor da variável media será retornado à rotina principal pelo nome da função. Veja então como fica o teste de mesa da rotina principal:
	a
	b
	c
	media
	Saída
	2.3
	67
	69.3
	47.43
	47.43
	4
	-8
	-4
	
	
	-3
	3
	0
	
	
	7
	12
	19
	
	
	21
	33
	54
	
	
Note que o valor da função apareceu na variável media existente na rotina principal e logo após ela foi escrita na área destinada à saída de dados.
Por que optamos por usar uma função ao invés de uma sub-rotina?
A função permite o retorno de apenas um único valor relacionado ao nome da função.
A sub-rotina envia / recebe valores através dos parâmetros definidos em cada uma delas. Sendo assim, seria necessário criar uma variável na rotina principal para que o valor desejado fosse trazido à memória principal para então ser utilizado. Neste caso para a impressão do mesmo.
Observação
Claro que poderíamos ter inserido a linha de escrita dentro da sub-rotina. Então o funcionamento da rotina seria parecido ao da função.
O melhor seria usar a função, pois em casos mais complexos, teríamos uma facilidade maior na manutenção do procedimento.