Definirea subprogramelor

Funcția main(), prezentă foarte des în programele noastre, este tot un subprogram.

Sintaxa generală

Subprogramele în C++ au următoarea structură:

<tip_de_dată> <nume_funcție> (<parametri_formali>) {
    // instrucțiuni
    [return <valoare>;] // obligatoriu dacă funcția nu e void
}

Componentele funcțiilor sunt așadar următoarele:

• <tip_de_dată>: tipul de dată al variabilei pe care funcția o returnează (void dacă funcția nu returnează nimic);
• <nume_funcție>: identificatorul unic al subprogramului, numele prin care noi vom face apelul funcției;
• <parametri_formali>: lista de parametri acceptată de funcție (se numesc parametri formali);
• return <valoare>: dacă funcția are un tip de return care nu este void, ea trebuie mereu să returneze o valoare de acel tip.

Exemplu de subprogram

În continuare găsiți schema unui algoritm ce folosește un subprogram și demonstrează câteva beneficii ale utilizării subprogramelor în C++:

#include <iostream>
using namespace std;

void Citire(int V[101], int& n) {
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> V[i];
    }
}

int main() {
    int A[101], B[101], C[101];
    int a, b, c;

    // se citesc 3 vectori diferiti
    Citire(A, a);
    Citire(B, b);
    Citire(C, c);

    // ...
    
    return 0;
}

Din antetul funcției:

• tipul de returnare este void, deci funcția nu returnează nimic;
• int V[101]: vector de intrare, transmis ca parametru;
• int& n: parametru transmis prin referință, modificat în interior.

Apelarea funcției în main() se face de 3 ori, pentru trei vectori diferiți. Se observă astfel cum s-a evitat repetarea logicii de citire a unui vector, fiind separată pentru vizibilitate și pentru a facilita reutilizarea codului.

Subprogramele C++ au două principale caracteristici ce vizează modul în care le definim și apoi cum le folosim în algoritmi.

Declarare (prototip)

Subprogramele se declară după zona variabilelor globale, înainte de funcția principală (int main()).

Este important de avut în vedere efectul de stivă. Funcțiile sunt vizibile doar în alte subprograme declarate ulterior, ele nu pot fi apelate în funcții ce precedă declararea.

În C++, putem să declarăm funcțiile înainte de a le descrie efectiv conținutul. Putem astfel la începutul unui program să declarăm doar antetul unui subprogram, având libertatea să definim conținutul funcției ulterior.

Alte câteva exemple de antete de funcții:

void f1(int A[101]);
unsigned f2(int x, float y);
bool f3(int a, short B[100][51], char c);

În antetul funcției nu este mereu necesară precizarea dimensiunii tablourilor (ex. vectori, sau matrice), dar este recomandată.

Apelarea unui subprogram

Un subprogram poate fi apelat în orice funcție în care este vizibil, adică atunci când declararea cel puțin a antetului a fost făcută înainte de apel.

Atunci când apelăm o funcție și completăm lista de parametri, în cazul tablourilor nu mai este necesară includerea dimensiunii. Apelurile funcțiilor declarate mai sus pot fi următoarele:

f1(A);
f2(x, y);
f3(a, B, c);

Variabilele trimise ca parametru pot avea și alte nume decât parametrii formali declarați în antetul funcției.