Subprograme definite de utilizator

Subprograme definite de utilizator în C++

În C++, orice subprogram se scrie ca funcție: definiția cuprinde antetul și corpul, delimitat de acolade.

Definirea unei funcții

Forma generală este:

tip_rezultat nume(parametri) {
    instrucțiuni;
    return rezultat;
}

Exemplu:

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

a și b sunt parametri formali, iar rezultatul funcției este un int. Instrucțiunea return încheie execuția funcției și transmite valoarea către locul apelului.

Apelul unei funcții

int x = 14, y = 9;
int m = maxim(x, y);
cout << m;

La apel, x și y sunt argumente. Ordinea lor corespunde parametrilor a și b. Funcția se execută, iar expresia maxim(x, y) este înlocuită cu valoarea întoarsă.

O funcție poate fi apelată direct într-o condiție:

if (maxim(a, b) > 100)
    cout << "mare";

Declararea prin prototip

Dacă funcția este scrisă după main, compilatorul trebuie să-i cunoască antetul înainte de primul apel. Se scrie un prototip:

#include <iostream>
using namespace std;

int maxim(int a, int b);

int main() {
    cout << maxim(4, 7);
}

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

Prototipul conține tipul rezultatului, numele și tipurile parametrilor, dar nu are corp. Caracterul ; de la sfârșit este obligatoriu.

Dacă definiția apare înainte de main, prototipul separat nu mai este necesar:

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

int main() {
    return maxim(4, 7);
}

Proceduri cu void

O procedură nu întoarce o valoare:

void afiseaza(int x) {
    cout << x << '\n';
}

Se apelează ca instrucțiune:

afiseaza(25);

Într-o procedură void se poate scrie return; pentru oprirea anticipată, dar nu return valoare;.

Transmiterea prin valoare

În transmiterea prin valoare, subprogramul primește o copie. Modificarea parametrului în interior nu modifică argumentul din programul apelant:

void mareste(int x) {
    x++;
}

int n = 5;
mareste(n);
cout << n;  // 5

Aceasta este forma implicită pentru parametrii simpli.

Transmiterea prin referință

Un parametru de forma tip& este o referință la variabila apelantului. Modificarea lui se vede și după revenirea din subprogram:

void mareste(int& x) {
    x++;
}

int n = 5;
mareste(n);
cout << n;  // 6

Referința se folosește când subprogramul trebuie să modifice direct o variabilă sau când se dorește întoarcerea mai multor rezultate.

Pentru un parametru care nu trebuie modificat, dar este un obiect mare, copierea poate fi evitată printr-o referință constantă:

int lungime(const string& s) {
    return s.length();
}

Vectorii ca parametri

Un vector transmis unei funcții poate fi modificat de funcție:

void dubleaza(int v[], int n) {
    for (int i = 0; i < n; i++)
        v[i] *= 2;
}

La apel se transmite numele vectorului și numărul de elemente:

int v[] = {1, 2, 3};
dubleaza(v, 3);

Funcția nu află singură câte elemente are vectorul. Dimensiunea trebuie transmisă separat sau stabilită printr-o constantă cunoscută.