Subprograme (proceduri și funcții)

Introducerea conceptului de modularizare a programelor prin utilizarea procedurilor și funcțiilor.

De ce împărțim programul în subprograme

Pe măsură ce programele cresc, scrierea întregului cod în funcția main devine greu de citit, greu de corectat și plină de bucăți repetate. Soluția se numește modularizare: împărțim programul în subprograme — bucăți de cod cu nume, care rezolvă fiecare câte o sarcină bine delimitată și pot fi apelate (chemate) ori de câte ori e nevoie.

Avantajele modularizării, așa cum se cer la teste:

• Evitarea repetării codului: scrii o singură dată calculul, îl apelezi de zece ori. Dacă găsești o greșeală, o corectezi într-un singur loc;
• Lizibilitate: un main care doar apelează citeste_date(), prelucreaza(), afiseaza_rezultat() se citește ca o poveste;
• Testare mai ușoară: fiecare subprogram se poate verifica separat, cu date alese de tine;
• Lucrul în echipă: fiecare membru poate scrie alt subprogram.

În C++ toate subprogramele se numesc funcții; în Pascal ele se împart în proceduri (nu întorc un rezultat) și funcții (întorc un rezultat). Aceeași distincție există și în C++, doar că procedura se scrie ca funcție cu tipul de retur void.

De altfel, ai folosit deja subprograme fără să știi: main este o funcție, iar cin și cout lucrează cu cod scris de alții și adus în program prin #include. Ideea de a folosi cod gata scris și verificat — bibliotecile — este una dintre cele mai importante din informatică.

Funcții care întorc un rezultat

O funcție primește date, face un calcul și returnează un rezultat. Definiția are patru părți: tipul rezultatului, numele, lista de parametri și corpul:

int suma(int a, int b) { return a + b; }

• int din față este tipul rezultatului — ce fel de valoare întoarce funcția;
• suma este numele, ales de programator după regulile identificatorilor;
• (int a, int b) sunt parametrii — datele de intrare ale funcției;
• return a + b; calculează rezultatul și îl trimite înapoi la locul apelului. return face două lucruri deodată: stabilește valoarea returnată și încheie imediat execuția funcției — orice instrucțiune scrisă după return-ul executat nu mai rulează.

Apelul se scrie exact ca folosirea unei variabile: x = suma(3, 5); sau cout << suma(3, 5); Valoarea returnată trebuie folosită — memorată, afișată, comparată. Un apel de funcție cu rezultat ignorat (suma(3, 5); pe o linie de sine stătătoare) compilează, dar rezultatul se pierde — o eroare de logică des întâlnită.

O funcție poate avea mai multe instrucțiuni return (de exemplu pe ramuri diferite ale unui if), dar la o execuție se atinge exact unul. Exemplu clasic — maximul a două numere:

int maxim(int a, int b) { if (a > b) return a; return b; }

Definițiile funcțiilor se scriu înainte de main (sau se anunță printr-un prototip), pentru că la compilare numele trebuie cunoscut înainte de primul apel.

Proceduri: subprograme fără rezultat returnat

Nu orice sarcină produce o valoare de calculat: uneori vrem doar să facem ceva — să afișăm un meniu, să desenăm o linie de steluțe, să afișăm un vector. Pentru asta folosim procedura — în C++, o funcție cu tipul de retur void (care înseamnă „nimic”):

void linie(int n) { for (int i = 1; i <= n; i++) cout << '*'; cout << endl; }

Apelul unei proceduri este o instrucțiune de sine stătătoare: linie(10); — nu se atribuie nimănui, pentru că nu există valoare de atribuit. Aici e simetria de reținut:

• funcție cu rezultat → apelul se folosește într-o expresie: x = f(a);
• procedură (void) → apelul stă singur: p(a);

Încercarea x = linie(10); este eroare de compilare — nu ai ce valoare să iei de la o funcție void.

Într-o procedură poți folosi return; simplu (fără valoare) ca să închei execuția mai devreme, dar nu return cu valoare.

Cum alegi între funcție și procedură? Regula practică: dacă răspunsul sarcinii este o valoare (o sumă, un maxim, un adevărat/fals), scrie o funcție care o returnează; dacă sarcina este o acțiune (afișare, desenare), scrie o procedură. La teste, cerința „scrieți o funcție care returnează...” îți impune funcție cu return, nu afișare! Confuzia dintre a returna și a afișa este penalizată: o funcție care face cout în loc de return nu returnează nimic și nu poate fi folosită în expresii.

Parametri formali și parametri efectivi

Parametrii formali sunt cei din definiția subprogramului — nume „de rezervă” care așteaptă valori. Parametrii efectivi (actuali) sunt valorile concrete trimise la apel. La int suma(int a, int b), a și b sunt formali; la apelul suma(3, x + 2), valorile 3 și x + 2 sunt efective.

Regulile de corespondență, verificate de compilator și de examinator:

• corespondența se face pe poziții: primul parametru efectiv merge în primul formal, al doilea în al doilea — nu după nume;
• numărul parametrilor efectivi trebuie să fie egal cu al celor formali;
• tipurile trebuie să se potrivească (sau să fie convertibile).

Modul standard de transmitere este prin valoare: subprogramul primește o copie a valorii, iar modificările făcute asupra parametrului formal nu afectează variabila din apel. Dacă funcția face a = 0; în corpul ei, variabila trimisă la apel rămâne neschimbată. Acesta e comportamentul implicit în C++ și sursa unei confuzii majore: mulți elevi cred că schimbarea parametrului în funcție schimbă și variabila de afară.

Când chiar vrem ca subprogramul să modifice variabila apelantului, folosim transmiterea prin referință, marcată în C++ cu & la parametrul formal: void dubleaza(int &x) { x = x * 2; } — acum modificarea se vede și în exterior. (În Pascal, echivalentul este cuvântul var.) Exemplul tipic: o procedură de interschimbare a două variabile funcționează doar cu parametri prin referință; cu transmitere prin valoare, se interschimbă copiile și variabilele reale rămân la fel.

Variabile locale și globale

Variabilele locale sunt declarate în interiorul unui subprogram (inclusiv în main) și există doar cât timp acesta se execută: se creează la intrare, dispar la ieșire. Ele sunt vizibile doar în subprogramul lor — main nu vede variabilele locale ale funcției suma și invers.

Variabilele globale sunt declarate în afara tuturor subprogramelor, de obicei sus, sub #include. Ele sunt vizibile din orice subprogram și trăiesc pe toată durata programului. Variabilele globale numerice sunt inițializate automat cu 0; cele locale, nu — pornesc cu valori reziduale imprevizibile.

Două subtilități cerute la teste:

• Două variabile locale cu același nume din subprograme diferite sunt complet independente — un x din main și un x din funcția f nu au nicio legătură, sunt zone de memorie diferite;
• Dacă o variabilă locală are același nume cu una globală, în interiorul subprogramului local o ascunde pe cea globală: numele se referă la varianta locală.

Care e stilul bun? Folosește variabile locale și parametri; evită globalele pe cât posibil. O funcție care primește tot ce îi trebuie prin parametri și întoarce rezultatul prin return este ușor de înțeles și de testat singură. Un program în care zece subprograme modifică aceleași globale devine imposibil de urmărit — nu mai știi cine a schimbat ce și când.

La exercițiile de urmărire a execuției cu subprograme, disciplina e aceeași ca la bucle: tabel cu variabilele, dar ținute pe coloane separate pentru fiecare subprogram, ca să nu amesteci localele unora cu ale altora — exact aici se pierd punctele.

Test — 6 întrebări ca la examen