Projetar com funções

Refinamento sucessivo

Do enunciado a um main de poucas linhas

Os programas da unidade 4 foram escritos inteiros dentro de main. Enquanto cabem numa tela, isso se tolera; ora, um programa de duzentas linhas escrito assim exige ter tudo na cabeça ao mesmo tempo, e só admite o teste do conjunto. O refinamento sucessivo, ou projeto descendente, inverte a ordem do trabalho: primeiro escreve-se o que o programa faz, na linguagem do problema, como uma sequência de chamadas a funções que ainda não existem; depois toma-se cada uma dessas funções como um problema novo, menor, e repete-se o procedimento até chegar a funções tão simples que o seu corpo se escreve sem decompor nada.

O problema a seguir serve de exemplo. Um inteiro $n \geq 1$ é perfeito se a soma dos seus divisores próprios (os positivos distintos de $n$) é igual a $n$, deficiente se é menor e abundante se é maior: $28 = 1 + 2 + 4 + 7 + 14$ é perfeito; 8, com $1 + 2 + 4 = 7$, é deficiente; 12, com $1 + 2 + 3 + 4 + 6 = 16$, abundante. Quer-se um programa que leia $n$ e escreva a soma dos seus divisores próprios e a sua categoria. O primeiro nível do projeto é main, e escreve-se antes de tudo:

#include <cstdint>#include <iostream>#include <print>#include <string>​enum class Kind { deficient, perfect, abundant };​// Soma dos divisores positivos de n.// Pré-condição: n >= 1.// Pós-condição: devolve a soma de todos os divisores positivos de n, incluído n.std::int64_t divisorSum(int n);​// Categoria de n segundo a soma dos seus divisores próprios.// Pré-condição: n >= 1.// Pós-condição: devolve deficient, perfect ou abundant conforme a soma seja menor, igual ou maior que n.Kind classify(int n);​// Nome de uma categoria, para escrevê-lo.// Pré-condição: nenhuma.// Pós-condição: devolve «deficiente», «perfeito» ou «abundante».std::string kindName(Kind kind);​int main(){    int n{};    std::cin >> n;    std::println("Divisores próprios de {}: somam {}", n, divisorSum(n) - n);    std::println("{} é {}", n, kindName(classify(n)));}

/usr/bin/x86_64-linux-gnu-ld.bfd: main.o: in function `main':main.cpp:27:(.text+0x22a): undefined reference to `divisorSum(int)'/usr/bin/x86_64-linux-gnu-ld.bfd: main.cpp:28:(.text+0x3fd): undefined reference to `classify(int)'/usr/bin/x86_64-linux-gnu-ld.bfd: main.cpp:28:(.text+0x40d): undefined reference to `kindName[abi:cxx11](Kind)'collect2: error: ld returned 1 exit status

O programa compila sem nenhum aviso, porque cada chamada concorda com a sua declaração, que é a única coisa que o compilador verifica, como ensinou a aula Funções. O que falha é a ligação: o ligador procura as definições e não as encontra (“undefined reference”, referência indefinida; o acréscimo [abi:cxx11] é uma marca interna do GCC para as funções que devolvem std::string). Esse estado é exatamente o do projeto neste ponto: as interfaces estão decididas, os corpos não. Se isto é assim, main já se lê como a especificação do programa, e as três declarações são as tarefas pendentes, cada uma menor que o problema original.

A árvore da decomposição

O segundo nível desce a cada declaração. kindName é uma decisão de três casos. classify apoia-se em divisorSum: um número é perfeito quando a soma de todos os seus divisores é $2n$. E divisorSum é o laço dos divisores em pares $(d, n/d)$ da aula Algoritmos numéricos, que para em $\sqrt{n}$. O resultado desenha-se como uma árvore: a raiz é o problema completo; os filhos de cada nó, os subproblemas que o resolvem; as folhas, operações que a linguagem já oferece.

Com a árvore completa, escrevem-se as definições de baixo para cima, de modo que cada função se apoia em outras já escritas:

#include <cstdint>#include <iostream>#include <print>#include <string>​enum class Kind { deficient, perfect, abundant };​// Soma dos divisores positivos de n.// Pré-condição: n >= 1.// Pós-condição: devolve a soma de todos os divisores positivos de n, incluído n.std::int64_t divisorSum(int n){    std::int64_t sum{0};    for (int d{1}; d <= n / d; ++d) {        if (n % d == 0) {            sum += d;            if (d != n / d) {                sum += n / d;            }        }    }    return sum;}​// Categoria de n segundo a soma dos seus divisores próprios.// Pré-condição: n >= 1.// Pós-condição: devolve deficient, perfect ou abundant conforme a soma seja menor, igual ou maior que n.Kind classify(int n){    const std::int64_t proper{divisorSum(n) - n};    if (proper < n) {        return Kind::deficient;    }    if (proper == n) {        return Kind::perfect;    }    return Kind::abundant;}​// Nome de uma categoria, para escrevê-lo.// Pré-condição: nenhuma.// Pós-condição: devolve «deficiente», «perfeito» ou «abundante».std::string kindName(Kind kind){    if (kind == Kind::deficient) {        return "deficiente";    }    if (kind == Kind::perfect) {        return "perfeito";    }    return "abundante";}​int main(){    int n{};    std::cin >> n;    std::println("Divisores próprios de {}: somam {}", n, divisorSum(n) - n);    std::println("{} é {}", n, kindName(classify(n)));}

28

Divisores próprios de 28: somam 2828 é perfeito

Três traços do resultado devem-se ao método. Primeiro, main não mudou ao escrever o que está abaixo. Segundo, a soma devolve-se como std::int64_t (de <cstdint>, o inteiro de 64 bits que a aula Recursão também usa), porque para $n$ próximo do máximo de int a soma dos seus divisores pode excedê-lo, e decidi-lo na interface protege todos os que chamam. Terceiro, cada função verifica-se separadamente: divisorSum(28) deve dar 56, divisorSum(1) deve dar 1 e divisorSum(36) deve dar 91, onde o par $(6, 6)$ se conta uma só vez; a última parte da aula converte essas verificações num programa.