Apelul funcțiilor

Intuiția

Când apelezi o funcție, controlul nu „dispare": el sare în funcție, iar pentru acel apel se creează un cadru — o cutiuță cu parametrii și variabilele locale ale funcției. Cât timp funcția lucrează, cadrul ei stă deasupra; când întâlnește return, cadrul se distruge și controlul revine la apelant, aducând valoarea întoarsă. Dacă o funcție apelează altă funcție, cadrele se așază unul peste altul ca niște farfurii pe o stivă: ultimul pus e primul luat.

Vezi cum funcționează

Urmărește stiva de apeluri: fiecare apel adaugă un cadru în vârf, iar fiecare return îl scoate. Cadrul din vârf e mereu funcția care lucrează chiar acum — stiva crește la coborâre și se micșorează la urcare.

Algoritmul pas cu pas

Urmărim ce face programul când main apelează media(4, 6), iar media apelează la rândul ei suma(4, 6). Reține regula: vârful stivei este funcția care rulează acum.

Pasul 1 — programul pornește. Pe stivă există doar main:

Pasul 2 — main apelează media(4, 6). Controlul sare în media; se creează un cadru nou cu a=4, b=6. El se așază deasupra:

Pasul 3 — în interiorul lui media, apare apelul suma(4, 6). Încă un cadru se pune deasupra, cu a=4, b=6. Acum trei cadre coexistă:

Pasul 4 — suma calculează 4 + 6 = 10 și face return 10. Cadrul lui se distruge, controlul revine la media, care primește valoarea 10:

Pasul 5 — media calculează 10 / 2 = 5 și face return 5. Cadrul ei se distruge, controlul revine la main cu valoarea 5:

Implementare C++

#include <iostream>
using namespace std;

// aduna doua numere si intoarce suma
int suma(int a, int b) {
    return a + b;          // un singur cadru, calcul simplu
}

// foloseste suma, apoi imparte la 2
int media(int a, int b) {
    int s = suma(a, b);    // apel: se creeaza un cadru nou pentru suma
    return s / 2;          // dupa return-ul lui suma, continuam de aici
}

int main() {
    int rezultat = media(4, 6);   // main apeleaza media, care apeleaza suma
    cout << rezultat << endl;     // 5
    cout << media(10, 20) << endl; // 15
    return 0;
}

Fiecare apel își creează propriul cadru. suma nu știe și nu îi pasă cine a chemat-o: primește două numere, întoarce suma, gata. media o folosește ca pe o cutie neagră. Iar main le orchestrează pe amândouă. Când controlul revine din media, valoarea 5 ajunge în rezultat — exact ca degetul care se întoarce pe rândul din rețetă.

Complexitate

Aici nu numărăm operații de algoritm, ci adâncimea stivei — câte cadre coexistă în momentul cel mai „adânc". Pentru lanțul main → media → suma sunt 3 cadre simultan.

Fiecare cadru ocupă memorie (parametrii + variabilele locale). Câtă vreme adâncimea e mică, e neglijabil. Dar dacă o funcție se apelează la nesfârșit (recursie fără oprire), cadrele se tot adună până umplu stiva — atunci programul se oprește cu stack overflow.