Proiectarea modulară

Modularizarea împarte un program în subprograme cu sarcini clare. Un subprogram primește date prin parametri și poate întoarce un rezultat. La clasa a IX-a, în Python putem scrie def numara_pozitive(a):, apoi parcurgem lista și returnăm contorul. Pentru [-1,2,3] rezultatul este 2. În programul principal apelăm subprogramul ori de câte ori avem nevoie; astfel aceeași logică nu se copiază în mai multe locuri.

Modularizarea împarte problema în subprobleme independente, fiecare rezolvată de un subprogram. Un subprogram are un nume, primește date prin parametri și poate returna un rezultat. Specificația lui precizează datele primite, rezultatul și condițiile în care funcționează (de exemplu „$n\ge 1$”). Avantajele sunt: aceeași logică nu se copiază în mai multe locuri, fiecare modul se testează separat, iar programul principal se citește ca o înșiruire de apeluri. Modulele comunică prin parametri și prin valoarea returnată, nu prin variabile ascunse.

Exemplul 1 — media valorilor pozitive. Problema se descompune în trei module: numaraPozitive (câte valori sunt pozitive), sumaPozitive (suma lor) și programul principal, care calculează media doar dacă există valori pozitive.

#include <iostream>
using namespace std;
int numaraPozitive(int a[], int n) {
    int cnt = 0;
    for (int i = 0; i < n; ++i)
        if (a[i] > 0) ++cnt;
    return cnt;
}
int sumaPozitive(int a[], int n) {
    int s = 0;
    for (int i = 0; i < n; ++i)
        if (a[i] > 0) s += a[i];
    return s;
}
int main() {
    int a[] = {-1, 2, 3, -4, 5};
    int n = 5;
    int k = numaraPozitive(a, n);
    if (k == 0)
        cout << "nu exista";
    else
        cout << sumaPozitive(a, n) / (double)k;
    return 0;
}

Pentru tabloul $-1,2,3,-4,5$ există $k=3$ valori pozitive, suma lor este 10, iar programul afișează 3.33333. Dacă niciun element nu este pozitiv, k este 0 și programul afișează nu exista în loc să împartă la zero. Fiecare funcție poate fi testată singură: pe un tablou fără valori pozitive (rezultat 0), pe unul mixt și pe unul cu toate valorile pozitive.

Exemplul 2 — un modul refolosit. Funcția estePrim primește un număr și întoarce 1 dacă este prim. Ea este scrisă o singură dată și apelată în orice alt modul care are nevoie de ea, de pildă pentru a număra și a aduna numerele prime din intervalul $[10;30]$.

#include <iostream>
using namespace std;
bool estePrim(int n) {
    if (n < 2) return false;
    for (int d = 2; d * d <= n; ++d)
        if (n % d == 0) return false;
    return true;
}
int main() {
    int nr = 0, s = 0;
    for (int x = 10; x <= 30; ++x)
        if (estePrim(x)) {
            ++nr;
            s += x;
        }
    cout << nr << ' ' << s;
    return 0;
}

Programul afișează 6 112: numerele prime din interval sunt 11, 13, 17, 19, 23 și 29, iar suma lor este 112. Dacă algoritmul de primalitate trebuie schimbat, modificarea se face într-un singur loc.

În Python aceeași organizare se obține cu funcții definite prin def; un parametru de tip listă permite funcției să parcurgă aceleași elemente.

Exemplul 3 — parametri prin referință. Un subprogram care trebuie să modifice variabilele apelantului primește parametri prin referință, marcați cu &. Parametrul este atunci un alt nume pentru variabila din apel, nu o copie.

#include <iostream>
using namespace std;
void interschimba(int &x, int &y) {
    int t = x;
    x = y;
    y = t;
}
int main() {
    int a = 3, b = 8;
    interschimba(a, b);
    cout << a << ' ' << b;
    return 0;
}

Programul afișează 8 3. Dacă antetul ar fi void interschimba(int x, int y), funcția ar schimba doar două copii, iar în main s-ar afișa în continuare 3 8. Variabila locală t există numai pe durata apelului.

Exemplul 4 — un modul construit pe altul. Cel mai mic multiplu comun al numerelor $a$ și $b$ se calculează cu relația $\mathrm{cmmmc}(a,b)=a/\mathrm{cmmdc}(a,b)\cdot b$, deci funcția cmmmc apelează funcția cmmdc, scrisă separat prin algoritmul lui Euclid.

int cmmdc(int a, int b) {
    while (b != 0) {
        int r = a % b;
        a = b;
        b = r;
    }
    return a;
}
int cmmmc(int a, int b) { return a / cmmdc(a, b) * b; }

Pentru $a=12$ și $b=18$, cmmdc parcurge perechile $(12,18)$, $(18,12)$, $(12,6)$, $(6,0)$ și întoarce 6, deci cmmmc(12, 18) este $12/6\cdot 18=36$. Împărțirea se face înaintea înmulțirii, ca produsul $a\cdot b$ să nu depășească inutil domeniul tipului int. Fiecare funcție se testează separat: cmmdc(12, 18) trebuie să dea 6, iar cmmmc(4, 6) trebuie să dea 12.

Specificația ca înțelegere între module. Pentru cmmdc(a, b) specificația spune: parametrii sunt întregi $a,b\ge 0$, nu ambii nuli, iar rezultatul este cel mai mare divizor comun. Dacă apelantul transmite $a=b=0$, funcția întoarce 0, o valoare fără sens ca divizor. Verificarea datelor de intrare aparține programului principal; modulul nu poate ghici ce valori i se vor transmite.

La apeluri succesive, urmărește valorile parametrilor și valoarea returnată, fără să presupui că variabilele locale ale unui apel rămân active în următorul. Pentru numaraPozitive aplicată tabloului $-1,2$ rezultatul este 1, iar pentru $0,0$ este 0. Dacă problema cere media, verifică separat ramura pentru numărul zero înainte de împărțire. În apeluri imbricate, f(f(x)), se evaluează întâi apelul interior, iar valoarea lui devine parametrul celui exterior. Un parametru transmis prin valoare este o copie: dacă void inc(int x) { x++; } este apelată cu o variabilă a = 5, după apel a rămâne 5; numai un parametru transmis prin referință, void inc(int &x), modifică variabila din apelant, care ajunge 6. Când un fragment de examen apelează o funcție de mai multe ori, scrie într-un tabel parametrul, valoarea returnată și, dacă există, variabilele modificate prin referință.

Exemplu în formatul examenului. Ce se afișează în urma executării programului de mai jos?

#include <iostream>
using namespace std;
int f(int x) { return x * 2 + 1; }
int g(int x) { return f(f(x)) - x; }
int main() {
    cout << g(3);
    return 0;
}

• a) 7
• b) 9
• c) 12
• d) 15

Răspunsul corect este c). Pentru g(3) se calculează întâi f(3), care este $3\cdot 2+1=7$. Apoi f(7) este $7\cdot 2+1=15$. Din rezultat se scade parametrul x, care are valoarea 3 în g: $15-3=12$. Varianta d) uită scăderea, iar varianta a) este valoarea lui f(3).

Un subprogram void nu întoarce o valoare, deci nu poate apărea într-o expresie: dacă inc este void, instrucțiunea x = inc(a); este greșită. Pentru interschimba(a, b) cu $a=3$ și $b=8$, după apel se afișează 8 3 dacă parametrii sunt prin referință și 3 8 dacă sunt prin valoare.

Greșeli frecvente

• Greșit: împărțirea în funcții face automat algoritmul corect.
  Corect: fiecare modul și legăturile dintre module trebuie verificate.
• Greșit: o variabilă locală dintr-un apel păstrează automat valoarea pentru apelul următor.
  Corect: în mod obișnuit, variabilele locale se creează pentru fiecare apel.
• Greșit: un modul poate schimba fără avertisment datele primite printr-o referință constantă.
  Corect: const interzice modificarea prin acel parametru.

Înainte și după