Aula 4

Resumo da matéria

Introdução à modularização

Todos conhecemos exemplos de modularização, i.e., sistemas que são compostos por módulos com funções bem definidas e tão independentes quanto possível. Por exemplo, a maior parte dos sistemas de alta fidelidade para audiófilos são compostos por módulos: o amplificador, o equalizador, o leitor de CD, o sintonizador, o leitor de cassetes, etc.

A divisão dum sistema em módulos tem várias vantagens. Para o fabricante, por um lado, a modularização tem a vantagem de reduzir a complexidade do problema, dividindo-o em sub-problemas mais simples, que podem inclusivamente ser resolvidos por equipas independentes. Até sob o ponto de vista do fabrico é mais simples alterar a composição de um módulo, por exemplo porque se desenvolveram melhores circuitos para o amplificador, do que alterar a composição de um sistema integrado. Por outro lado, é mais fácil detectar problemas e resolvê-los, pois os módulos são, em princípio, razoavelmente independentes. Claro que os módulos muitas vezes não são totalmente independentes. Por exemplo, o sistema de controlo à distância duma aparelhagem implica interacção com todos os módulos simultaneamente. A arte da modularização está em identificar claramente que módulos devem existir no sistema, de modo a garantir que as ligações entre os módulos são minimizadas e que a sua coesão interna é máxima. Isto significa que, no caso dum bom sistema de alta fidelidade, os cabos entre os módulos são simplificados ao máximo e que os módulos contêm apenas os circuitos que garantem que o módulo faz a sua função. A coesão tem portanto a ver com as ligações internas a um módulo, que idealmente devem ser maximizadas. Normalmente, um módulo é coeso se tiver uma única função, bem definida.

Para um utilizador, por outro lado, a modularização tem como vantagem principal permitir a alteração de um único módulo sem ter de comprar um sistema novo. Claro que para isso acontecer o novo módulo tem de (1) ter a mesma função do módulo substituido e (2) possuir uma interface idêntica (os mesmo tipo de cabos com o mesmo tipo de sinal eléctrico). Isto é, os módulos, do ponto de vista do utilizador, funcionam como "caixas pretas" com uma função bem definida e com interfaces bem conhecidas. Para o utilizador o interior de um módulo é irrelevante. Mas a modularização tem outras vantagens: o amplificador pode no futuro ser reutilizado num sistema de vídeo, por exemplo, evitando a duplicação de circuitos com a mesma função (se nunca pensou nisso, lembre-se que a televisão tem o seu próprio amplificador, normalmente de fraca qualidade, servindo apenas para a encarecer). Aliás, o amplificador era já utilizado para amplificar o sinal de vários outros módulos (e.g. o leitor de CD ou o sintonizador).

As vantagens da modularização são muitas, como vimos. A modularização é um dos métodos usados em engenharia da programação para desenvolvimento de programas de grande escala. Mas a modularização é útil mesmo para pequenos programas, quanto mais não seja pelo treino que proporciona. Estes assuntos serão estudados com mais profundidade em Engenharia da Programação (IGE) e Concepção e Desenvolvimento de Sistemas de Informação (ETI).

As vantagens da modularização para a programação são pelo menos as seguintes [1]:

Facilita a detecção de erros, pois é em princípio simples verificar qual é o módulo responsável pelo erro.
É mais fácil testar os módulos individualmente do que o programa completo.
É mais fácil fazer a manutenção (correcção de erros, melhoramentos, etc.) módulo por módulo do que no programa total. Além disso, a modularização aumenta a probabilidade dessa manutenção não ter consequências nefastas nos outros módulos do programa.
Permite o desenvolvimento independente dos módulos. Isto simplifica o trabalho em equipa, pois cada elemento, ou cada sub-equipa, tem a seu cargo apenas alguns módulos do programa.
Porventura a mais evidente vantagem da modularização em programas de pequena escala, mas também nos de grande escala, é a possibilidade de reutilização do código* desenvolvido.

Um programador assume, ao longo do desenvolvimento dum programa, os dois papeis descritos acima: por um lado é fabricante, pois é sua responsabilidade desenvolver módulos; por outro é utilizador, pois fará com certeza uso de outros módulos, desenvolvidos por outrem ou por ele próprio no passado. Esta é uma noção muito importante. É de toda a conveniência que um programador possa ser um mero utilizador dos módulos já desenvolvidos, sem se preocupar com o seu funcionamento interno: ele sabe qual a interface do módulo e qual a sua função, e usa-o. Isto permite reduzir substancialmente a complexidade da informação que o programador tem de ter presente na sua memória, conduzindo por isso a substanciais ganhos de produtividade e a uma menor taxa de erros.

* Dá-se o nome de código a qualquer pedaço de programa numa dada linguagem de programação.

Funções e procedimentos em C++

A modularização é, na realidade um processo hierárquico: muito provavelmente cada módulo dum sistema de alta fidelidade é composto por sub-módulos razoavelmente independentes. O mesmo se passa na programação. Para já, no entanto, restringir-nos-emos às unidades atómicas de modularização em programação: as funções e os procedimentos.

Função

Conjunto de instruções, com interface bem definida, que efectua um dado cálculo.

Procedimento

Conjunto de instruções, com interface bem definida, que faz qualquer coisa.

Sintaxe

Uma função é constituida por um cabeçalho e por um corpo. No cabeçalho são indicados: (1) o nome da função, (2) os parâmetros da função (nome e tipo) e (3) o tipo do valor devolvido por essa função. No exemplo seguinte temos o cabeçalho de uma função que tem dois parâmetros (ambos números inteiros) e devolve um valor lógico. O nome dado a esta função é sãoIguais.

bool sãoIguais(int x, int y)

O corpo desta função poderia ser:

{
    bool valor_a_devolver = x == y;

    return valor_a_devolver;
}

ou simplesmente:

{
    return x == y;
}

Idealmente, quer as funções quer os procedimentos devem ser pequenos, com corpos contendo entre uma e dez instruções. Muito raramente haverá boas razões para ultrapassarem as 60 linhas.

Invocação ou chamada

Depois de definida, uma função pode ser utilizada noutros locais dum programa. A utilização típica é invocar ou chamar a função para que ela seja executada. A invocação da função acima pode ser feita como se segue:

int a = 1;
bool iguais;
...
   iguais = sãoIguais(a, 2);
...

Quando a função é invocada:

São criados os parâmetros x e y, que funcionam como outras variáveis quaisquer.
É atribuido a cada um dos parâmetros x e y o valor das expressões colocadas entre parênteses na chamada da função, neste caso simplesmente os valores 1 e 2. A estas expressões chama-se argumentos.
O (fluxo de execução do) programa passa para a primeira instrução da função.

Em seguida o corpo da função é executado, dizendo-se que a função termina quando se atinge a chaveta final do seu corpo ou quando ocorre uma instrução de retorno, que consiste na palavra-chave* return seguida duma expressão. Ao terminar na instrução de retorno acontece o seguinte:

São destruídos os parâmetros x e y.
O (fluxo de execução do) programa passa para a instrução de invocação da função.
É atribuido à variável igual o valor resultante da expressão que se encontra a seguir à palavra-chave return. Diz-se que a função devolveu um valor.

Os parâmetros e valores devolvidos de uma função podem ser de qualquer tipo básico do C++ ou de tipos de dados definidos pelo utilizador (falaremos destes tipos brevemente). Os tipos dos argumentos têm de ser compatíveis com o tipo dos parâmetros respectivos (não esquecer que todas as expressões em C++ são de um determinado tipo). Como é evidente, uma função pode devolver um único valor do tipo indicado na definição.

* Palavra-chave é o nome que se dá aos identificadores com um significado especial em C++, tais como int e return.

Parâmetros

Os parâmetros duma função não passam de variáveis locais (ver abaixo). Mas têm uma particularidade: são automaticamente inicializadas com o valor dos argumentos em cada chamada da função.

Argumentos

Argumentos são as expressões cujo valor é utilizado para se inicializar os parâmetros numa dada chamada da função.

Retorno e devolução

Em inglês a palavra return tem dois significados distintos: retornar (ou regressar) e devolver. Sendo o português mais rico (neste caso), usar-se-ão palavras distintas. Assim, dir-se-á que uma função (ou procedimento) retorna quando termina a sua execução e o fluxo de execução regressa ao ponto de invocação. Dir-se-á ainda que uma função, ao retornar, devolve um valor que pode ser usado na expressão em que a função foi invocada. No exemplo acima o valor lógico devolvido é usado numa expressão de atribuição.

Significado de `void`

Um procedimento em C++ tem a mesma sintaxe que uma função, mas normalmente não devolve qualquer valor. Esse facto é indicado colocando a palavra-chave void no local do tipo do valor de devolução.

Passagem de argumentos por valor e por referência

Observe o seguinte exemplo de procedimento, cujo objectivo é (seria) trocar os valores de duas variáveis (se funcionasse...):

// Atenção! Esta função não funciona!
void trocaValores(int x, int y)
{
    int auxiliar = x;
    x = y;   
    y = auxiliar;

    // Não há instrução de return explícita, pois trata-se dum 
    // procedimento que não devolve qualquer valor.
    // Alternativemente porder-se-ia fazer return;
}

O que acontece ao se invocar esta função como se segue?

int a = 1, b = 2;
...
Troca_valores(a, b);    // Note que não existe utilização do
                        // valor devolvido pela função, dado que
...                     // esta função não devolve qualquer valor.
cout << a << ' ' << b << endl;

São criados os parâmetros x e y.
É atribuído a x o valor de a (1) e a y o valor de b (2).
Durante a execução da função os valores de x e y são trocados.
Antes de a função terminar, a variável (ou parâmetro) x tem o valor 2 e a variável y o valor 1.
Quando termina a execução da função são destruídos os parâmetros x e y.

Ou seja, não há qualquer efeito sobre os valores das variáveis a e b! Os parâmetros mudaram de valor dentro da função mas as variáveis a e b não mudaram de valor: a continua a conter 1 e b 2. A este tipo de comportamento chama-se passagem de argumentos por valor, e é, normalmente, um comportamento desejável. Só em alguns casos, como neste exemplo, esta é uma característica indesejável.

Para resolver este tipo de problemas, onde é do nosso interesse que o valor das variáveis que são usadas como argumentos seja alterado dentro duma função, existe o conceito de passagem de argumentos por referência. A passagem de um argumento por referência é indicada no cabeçalho da função colocando o símbolo & depois do tipo do parâmetro pretendido, como se pode ver abaixo:

void trocaValores(int& x, int& y)
{
    int auxiliar = x;
    x = y;   
    y = auxiliar;
}

Ao invocar como anteriormente:

Os parâmetros x e y tornam-se sinónimos (referências) das variáveis a e b. Aqui não é feita a cópia dos valores de a e b para x e y. O que acontece é que os parâmetros x e y passam a referir-se às mesmas posições de memória onde estão guardadas as variáveis a e b.
No corpo da função o valor que está guardado em x é trocado com o valor guardado em y. Dado que x se refere à mesma posição de memória que a e y à mesma posição de memória que b, ao fazer esta operação estamos efectivamente a trocar os valores das variáveis a e b.
Quando termina a execução da função são destruídos os sinónimos x e y das variáveis a e b (que permanecem intactas), ficando os valores destas alterados (trocados).

Como só podem existir sinónimos/referências de entidades como as variáveis (i.e., de entidades que têm posições de memória associadas), a chamada

trocaValores(20, a + b);

não faz qualquer sentido e conduz a dois erros de compilação.

Variáveis locais e globais

Uma observação cuidadosa dos exemplos das aulas anteriores revela que afinal main não passa de uma função. Mas é uma função especial: é no seu início que começa a execução do programa.

Assim sendo, verifica-se também que até agora só definimos variáveis dentro de funções. A essas variáveis chama-se variáveis locais. As variáveis locais podem ser definidas em qualquer ponto duma função onde possa estar uma instrução.

Alternativamente, existem variáveis globais, que se definem tal como as locais mas fora de qualquer função.

Âmbito ou visibilidade de variáveis

As variáveis globais são visíveis (isto é, utilizáveis em expressões) desde a sua definição até ao final do ficheiro onde se encontram (ver-se-á mais tarde que um programa pode consistir de vários ficheiros).

As variáveis locais são visíveis desde o ponto de definição até à chaveta de fecho do bloco de instruções onde foram definidas.

Quanto mais estreito for o âmbito de visibilidade duma variável, menores os danos causados por possíveis utilizações erróneas. Assim, as variáveis locais devem-se definir imediatamente antes da primeira utilização.

Um dos principais problemas com a utilização de variáveis globais tem a ver com o facto de estabelecerem ligações entre módulos (funções ou procedimentos) que não são explícitos na sua interface, i.e., na informação presente no cabeçalho. As variáveis globais são assim uma fonte de erros, que ademais são difícies de corrigir. O uso de variáveis globais é, por isso, fortemente desaconselhado.

Duração ou permanência de variáveis

Quando é que as variáveis existem, i.e., têm espaço de memória reservado para elas? As variáveis globais existem sempre desde o início ao fim do programa, e por isso dizem-se estáticas. As variáveis locais (parâmetros de funções incluídos) existem em memória apenas enquanto o bloco de instruções em que estão inseridas está a ser executado, sendo assim potencialmente "criadas" e "destruídas" muitas vezes ao longo de um programa. Variáveis com estas características dizem-se automáticas.

Inicialização

As variáveis globais são sempre inicializadas durante a definição com um valor nulo, excepto se se indicar outro valor. As variáveis locais (por uma questão de eficiência) não são incializadas de todo, contendo inicialmente valores arbitrários (i.e., lixo). Sempre que possível, deve-se inicializar explicitamente as variáveis com valores apropriados. Mas não se deve inicializar "com qualquer coisa" só para o compilador não "chatear".

Nomes de funções e procedimentos

Tal como no caso das variáveis, o nome das funções e dos procedimentos deverá reflectir claramente aquilo que é calculado ou aquilo que é feito. Assim, as funções têm tipicamente como nome o nome da entidade calculada (e.g. seno, coseno, comprimento) enquanto os procedimentos têm normalmente como nome o verbo indicador da acção, possivelmente seguido de complementos (e.g., acrescenta, copiaSemDuplicações).

Uma excepção a estas regras dá-se para funções cujo resultado é um valor lógico ou booleano. Nesse caso o nome da função deve ser um predicado, sendo o sujeito um dos argumentos da função (ou no caso de métodos de classes, o objecto em causa*), de modo que a frase completa seja uma proposição (verdadeira ou falsa). Por exemplo, estáVazia(fila) ou simplesmente vazia(fila). Só se devem usar abreviaturas quando forem bem conhecidas.

Idealmente, os procedimentos têm um único objectivo, sendo por isso descritíveis usando apenas um verbo. Assim, quando a descrição de um procedimento obrigar há utilização de dois ou mais verbos, esse procedimento é um bom candidato a ser dividido em dois ou mais procedimentos...

A linguagem C++, sendo imperativa, i.e., consistindo os programas em sequências de instruções, não representa o conteúdo semântico do código senão implicitamente. I.e., o corpo duma função diz como se calcula qualquer coisa, mas não diz o que se calcula. É assim de toda a conveniência que, usando as regras atrás, esse o que fique explícito no nome da função, passando-se o mesmo quanto aos procedimentos.

* Assunto a tratar em aulas posteriores.

Exemplo

O seguinte exemplo utiliza uma função que calcula o máximo divisor comum como auxiliar no cálculo da soma de duas fracções. Será capaz de explicar qual a vantagem de reduzir as fracções antes de proceder ao cálculo? Para quê dividir numerador e denominador por divisor?

#include <iostream>

using namespace std;

// Calcula o máximo divisor comum de dois inteiros.
// Assume-se que n > 0 e m >= 0 (não existe mdc(m, n) se ambos
// forem zero).
int mdc(int m, int n)
{
    while(m != 0) {
        int auxiliar = n % m;
        n = m;
        m = auxiliar;
    }
    return n;
}

// Reduz uma fracção.
void reduzFracção(int& numerador, int& denominador)
{
    int divisor = mdc(numerador, denominador);
    numerador /= divisor;
    denominador /= divisor;
}

// Programa que calcula a soma de duas fracções (positivas):
int main()
{
    cout << "Introduza duas fracções (numerador denominador): ";
    int numerador1, denominador1, numerador2, denominador2;
    cin >> numerador1 >> denominador1 >> numerador2 >> denominador2;

    // Reduzem-se as fracções:
    reduzFracção(numerador1, denominador1);
    reduzFracção(numerador2, denominador2);

    // Cálculo do resultado:
    int divisor = mdc(denominador1, denominador2);
    int numerador_do_resultado =
        numerador1 * (denominador2 / divisor) +
        numerador2 * (denominador1 / divisor);
    int denominador_do_resultado =
        denominador1 / divisor * denominador2;

    // Redução do resultado:
    reduzFracção(numerador_do_resultado, denominador_do_resultado);

    // Escrita do resultado:
    cout << numerador_do_resultado << '/' 
         << denominador_do_resultado << endl;
}

Note-se que o algoritmo do mdc utilizado não é o que se desenvolveu no início destas aulas! Neste caso usa-se o algoritmo de Euclides, que decorre naturalmente das seguintes propriedades do mdc:

mdc(m, n) = mdc(n % m, m)
mdc(m, 0) = m, se m positivo (e também mdc(0, n) = n, se n positivo)

O algoritmo usado deixou de ser uma busca exaustiva do mdc para passar a ser uma redução sucessiva do problema até à trivialidade. A demonstração da sua correcção faz-se exactamente da mesma forma que no caso da busca exaustiva, e fica como exercício para o leitor.

Exercícios

#include <iostream>
using namespace std;

// Calcula o quadrado dum número.
float quadrado(float x)
{
    return x * x;
}

// Este programa chama a função acima para calcular o quadrado
// dum número.
int main()
{
    float valor, valor_quadrado;

    cout << "Introduza um numero : ";
    cin >> valor;

    valor_quadrado = quadrado(valor);

    cout << "O quadrado de " << valor << " é " 
         << valor_quadrado << endl;
}

1. Copie o programa acima e faça o seu traçado (execute-o em modo de depuração [debug]). Quando for executar a linha onde a função é invocada use o botão Step Into em vez de F10 (Step Over). Verifique que a próxima instrução executada é a primeira que se encontra no corpo da função. Observe que as variáveis que se encontram na janela denominada Locals mudam quando entra na função.

2.a) Implemente uma função que, dados três valores de vírgula flutuante interpretados como componentes dum vector, calcule a sua norma. Lembre-se que a norma de um vector é a raiz quadrada do somatório dos quadrados de cada um dos seus componentes. Faça um pequeno programa para testar esta função (como foi feito no exemplo). Para calcular a raiz quadrada use a função sqrt, acrescentando ao topo do seu programa a linha #include<cmath>.

2.b) Usou a função float quadrado(float a) na alínea anterior? Se não usou, modifique o seu programa de modo a usar.

2.c) Crie uma função que, dados três valores de vírgula flutuante interpretados como componentes dum vector, o normalize. Normalizar um vector é calcular o seu versor, i.e., dividir cada um dos componentes pela norma do vector.

3. Faça uma função que calcule a raiz positiva de uma equação de segundo grau. Recorda-se que a raiz positiva de uma equação do segundo grau é dada por (b + (b²- 4ac)^0,5) / 2a. Assuma que b² - 4ac >= 0.

4. Construa uma função que devolva o valor booleano true caso os seus dois argumentos (do tipo char) sejam iguais e false no caso contrário.

5. Crie uma função com dois argumentos inteiros que divida ambos os seus parâmetros de entrada por 2. Ao retornar, os valores dos argumentos de entrada da função devem ter sido modificados.

Exercícios propostos

1. Crie uma função que calcule n!, isto é, o factorial dum inteiro n. Não use ciclos.

2. Considere uma sucessão equência de números que denota o número de coelhos existente numa exploração em determinado mês. Em cada mês cada par de coelhos procria dando origem a outros dois coelhos. Estes dois coelhos começam a reproduzir-se apenas dois meses mais tarde. Portanto, se comprarmos dois coelhos-bebés no primeiro mês, no segundo mês teremos ainda um par de coelhos, mas no terceiro teremos já dois pares de coelhos. No quarto mês os primeiros reproduzem-se novamente (embora os últimos ainda não o possam fazer) e portanto teremos três pares de coelhos. No quinto mês dois desses três pares já se podem reproduzir do que resultam cinco coelhos. E assim sucessivamente. Se nenhum dos coelhos morrer, o número de pares de coelhos existente em cada mês é dado pela chamada sucessão de Fibonacci. Essa sucessão pode ser definida por: f₀ = 0, f₁ = 1, e f_n = f_n_-1 + f_n_-2 se n > 1. Os primeiros termos da sequência são portanto: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

Crie uma função que calcule quantos coelhos há na exploração num dado mês dado como argumento. Não use ciclos. Teste o funcionamento da sua função com meses de 0 a 40 (não se admire se levar muito tempo a calcular estes valores para meses superiores a 30). Faça um traçado da execução para seis meses e tente explicar porque leva tanto tempo a calcular para meses superiores.

Referências

[1] Doug Bell, Ian Morrey e John Pugh, "Software Engineering: A Programming Approach", segunda edição, Prentice Hall, Nova Iorque, 1992.