Exercícios Resolvidos de Analisando seu programa

Ver Teoria

Enunciado

Entre o programa abaixo no editor do MATLAB:

Lembre de adicionar os comandos c l e a r   a l l e c l c no começo do programa.

  1. Rode o programa e corrija os erros de sintaxe;
  2. Crie dois breakpoints, nas linhas:
  3. f o r   k   =   1 : 1 : l e n g t h ( v )     e     r e s u l t   =   r e s u l t   +   v

  4. Debugue o programa avançando linha por linha do programa e observando o Workspace e o Command Window, procurando algum erro. Corrija os erros lógicos.
  5. Limpe os breakpoints da letra b e rode o programa corrigido.

Passo 1

O enunciado nos deu um código que contém alguns erros e pede para nós o corrigirmos. A intenção do código é gerar um vetor de 30 elementos e somar somente os elementos positivos. Mas calma que eu já vou explicar isso em detalhes no próximo passo. Vamos entender o que o enunciado quer primeiro.

Na letra a, é pedido para corrigirmos erros de sintaxe. Erros de sintaxe em programação são erros causados quando não seguimos as regras da linguagem que estamos utilizando, no nosso caso, o MATLAB. Os erros de sintaxe impedem a execução do programa.

A letra b pede para criarmos dois breakpoints, para ajudar a responder a letra c. Na letra c, nos é pedido para corrigir erros lógicos. Em programação, erros lógicos não impedem a execução do programa. Eles levam a uma saída diferente da desejada e só podem ser detectados pelo programador ou pela programadora. O debugger do MATLAB nos ajuda a encontrar erros lógicos e a corrigi-los, por isso o usaremos para responder à letra c.

Finalmente, a letra d pede para tirarmos os breakpoints criados na letra b e para rodar o programa por completo.

Passo 2

Crie um script novo no MATLAB e copie nele o programa do enunciado. Antes de rodarmos o programa e procurarmos eventuais erros, vamos ver o que cada linha significa e o que o programa faz (ou o que deveria fazer):

Na linha 1, temos o comando c l e a r   a l l . Este comando limpa o Workspace do MATLAB cada vez que o programa é rodado. Como procuramos erros no código e teremos que rodá-lo várias vezes para ver se corrigimos alguma coisa, é importante limpar o Workspace a cada tentativa.

Na linha 2, o comando c l c limpa o Command Window do MATLAB cada vez que o programa é executado. Novamente, como vamos rodar o código diversas vezes, é importante limpar o Command Window a cada tentativa, para ficar mais fácil de ver qual erro foi corrigido e qual é o erro a ser corrigido na sequência, caso exista.

Na linha 4, criamos um vetor chamado v , que contém 30 números inteiros entre -10 e 100, gerados de forma aleatória. O vetor v é criado usando duas funções do MATLAB: r a n d ( ) e r o u n d ( ) . A função r a n d ( ) serve para gerar números reais aleatórios, dentro do intervalo [0,1]. Já a função r o u n d ( ) serve para arredondar números quebrados para o inteiro mais próximo.

Vamos ver como é a estrutura de cada uma destas duas funções. A função r a n d ( ) tem a seguinte estrutura:

A   =   r a n d ( n _ l i n h a s ,   n _ c o l u n a s )

Ela retorna uma matriz A com n _ l i n h a s e n _ c o l u n a s , composta por números aleatórios, que vão de 0 a 1.

A função r o u n d ( ) tem o formato:

Y   =   r o u n d ( X )

Ela arredonda cada elemento de X para o inteiro mais próximo.

Logo, na linha 4, o vetor v é criado seguindo estas etapas:

  • A primeira parte da linha que é executada é r a n d ( 1,30 ) , que gera um vetor com 30 elementos aleatórios, entre 0 e 1. O vetor resultante é multiplicado por 110. Assim passamos a ter 30 elementos variando entre 0 e 110;
  • Em seguida, -10 é somado ao vetor resultante. Isto é feito para que os elementos de v no final tenham um valor entre -10 e 100;
  • Finalmente, cada elemento do vetor gerado na etapa acima é arredondado para o inteiro mais próximo, por meio da função r o u n d ( ) .

Na linha 6, iniciamos um laço f o r , para varrer cada elemento do vetor v . É criada uma variável de controle k , que vai de 1 até o número de elementos de v , isto é, 30, com um passo de 1. O número de elementos de v é dado pela função l e n g t h ( ) , que retorna a quantidade de elementos de um vetor.

Na linha 7, criamos uma condição para avaliar cada elemento de v , verificando se ele é maior ou igual a 0, isto é, positivo. Fazemos isso para pegarmos somente elementos de v que sejam positivos, para fazer a soma na linha seguinte.

A linha 8 adiciona um elemento positivo de v , a cada iteração, à soma obtida na iteração anterior.

A linha 9 encerra a condição da linha 7 e a linha 10 encerra o laço f o r .

A linha 12 apresenta no Command Window do MATLAB a soma dos elementos positivos de v .

Agora que sabemos o que cada linha significa, vamos executar o programa para encontrar os erros de sintaxe e resolver a letra a do exercício.

Ao rodarmos o programa, aparece a seguinte mensagem no Command Window:

Note que apareceu a string dentro do comando d i s p ( ) da linha 12. Isso quer dizer que não há erros de sintaxe, já que o programa foi executado.

Contudo, há outros erros. Veja que o MATLAB indicou que há um erro na linha 12: ele não reconheceu a variável r e s u l t . Isso quer dizer que a linha 8 não foi executada. Para encontrarmos a fonte do problema, devemos debugar nosso programa.

Passo 3

Para começarmos a debugar, precisamos criar breakpoints, para o MATLAB entrar em modo debugger. Por isso, neste passo vamos responder a letra b do exercício.

Na letra b, é pedido para criar dois breakpoints, nas linhas:

f o r   k   =   1 : 1 : l e n g t h ( v )     e     r e s u l t   =   r e s u l t   +   v

Que são as linhas 6 e 8 do programa. Para criar os breakpoints, clique na barra cinza à esquerda do código, na janela do Editor do MATLAB, nas linhas onde queremos que a execução programa seja interrompida temporariamente. Aparecerão duas bolas vermelhas:

Essas duas bolas vermelhas são os breakpoints.

Pronto, a letra b do exercício está feita ;)

Passo 4

Com os breakpoints criados, podemos debugar o programa e fazer a letra c do exercício. A letra c pede para executar o programa linha por linha e, enquanto executamos, devemos observar o Workspace e o Command Window, para achar o erro no código.

Para ativar o modo debugger do MATLAB, mande rodar o programa. O programa vai ser executado até a linha 6, onde ele será interrompido. A linha onde o programa foi interrompido é indicada por uma flechinha verde:

Olhando o Workspace, vemos que a variável v foi criada sem problemas:

Vamos executar o programa linha por linha como o enunciado mandou. Para isso, aperte o botão “Step” ou use o atalho do teclado F10. Com isto, a flechinha verde desceu para a linha 7, indicando que a linha 6 foi executada:

Observe o Workspace: a variável de controle k foi criada e é igual a 1.

Vamos executar outra linha novamente. Aperte F10 ou botão “Step”. Ao fazer isso, a flechinha pulou da linha 7 para a linha 9, indicando que a condição do i f não foi respeitada:

Continue executando linha por linha, até atingir as 30 iterações. Você vai perceber que em nenhum momento a condição i f será respeitada, fazendo com que a variável r e s u l t não seja criada nem atualizada.

Isto acontece devido à forma como a condição do i f da linha 7 foi escrita: nela, o vetor inteiro v foi avaliado, e não somente um elemento dele. O que a gente queria era analisar os 30 elementos do vetor (procurando pelos positivos) e foi por isso que criamos um loop. Mas estamos fazendo outra coisa. Estamos analisando 30 vezes se o vetor inteiro é positivo.

Um vetor é positivo se todos os seus elementos são positivos. E, como é muito provável que o vetor v tenha pelo menos um elemento negativo, avaliando ele no todo, a condição v > = 0 será sempre falsa e a linha 8 não será executada em momento algum. Encontramos aqui o primeiro erro lógico do programa.

Interrompa o debugger clicando em “Quit debugging” para corrigirmos o erro da linha 7.

Passo 5

Para corrigir o erro lógico da linha 7, adicione ( k ) à direita da v , na condição do i f , como na imagem abaixo:

Fazendo isso, um elemento de v será avaliado por vez na linha 7. Quando o laço for iniciar, k = 1 e a linha 7 vai avaliar v ( 1 ) , que é o primeiro elemento de v . Na segunda iteração, k = 2 e v ( 2 ) será avaliado na condição do i f , e assim sucessivamente. A cada iteração o elemento v ( k ) , que ocupa a posição k , é avaliado.

Note que na linha 8 também temos um vetor v , que está sendo somado a r e s u l t . Novamente temos o vetor inteiro, onde deveria ser apenas um dos seus elementos. Como queremos que seja somado um elemento positivo por vez, vamos colocar um ( k ) à direita de v nesta linha também:

Bora ver o que acontece se executarmos o programa de novo? Ele vai ser interrompido novamente na linha 6, por causa do breakpoint. Execute a linha 6 apertando F10 ou o botão “Step”, para irmos para a linha 7 e execute esta linha em seguida. Perceba que agora conseguimos entrar no bloco do i f :

Como é a primeira iteração, k   =   1 , e a condição do i f foi atendida, isto quer dizer que o primeiro elemento de   v é positivo. Como conseguimos entrar pelo menos uma vez no bloco i f e atingir a linha 8, isto significa que corrigimos o primeiro erro de lógica. Ufa! Então vamos continuar!

Passo 6

Execute a linha 8 apertando F10 ou “Step”. Aparecerá a seguinte mensagem de erro no Command Window:

O MATLAB nos avisa que há um erro na linha 8: ele não reconheceu a variável r e s u l t . Isto porque ela não foi definida antes da linha 8.

Para corrigirmos o erro, interrompa o debugger, crie a variável r e s u l t na linha acima do laço f o r e diga que ela é igual a 0:

A variável r e s u l t representa a soma dos elementos positivos de v . Ela começará no programa como r e s u l t = 0 e será atualizada a cada iteração do laço f o r , quando a linha 8 for executada. Ela receberá ela mesma somada com o elemento de v da iteração corrente. Desta forma, quando o laço f o r estiver concluído, r e s u l t terá a soma de todos os elementos positivos de v .

Vamos testar novamente. Rode o programa para o MATLAB entrar em modo debugger e execute uma linha por vez até que a linha 8 seja atingida. Com a alteração que fizemos, não aparecerá mais o erro, pois a variável r e s u l t foi definida. Continue executando o código linha por linha e você verá que a variável r e s u l t muda a cada iteração.

Passo 7

Continue executando o programa linha por linha até o final. Quando o laço f o r terminar, a linha 12 do código é executada e a variável r e s u l t é impressa no Command Window:

Lembre que a sua variável r e s u l t   com certeza vai ser diferente da minha, pois v é criado de forma aleatória.

Como chegamos até o final do programa sem erros, o programa foi corrigido e podemos fazer a letra d do exercício.

Passo 8

A letra d do exercício pede para apagar os breakpoints e rodar o programa. Para apagá-los, clique neles e eles desaparecerão. Ou clique em “Breakpoints” -> “Clear all”:

Isto também fará com que todos os breakpoints sumam.

Executando o programa, temos o seguinte resultado no Command Window:

Note que ele é diferente do passo anterior, pois v é criado de forma aleatória.

Resposta

Ei, a resposta está no passo a passo :)