Funcții în C++ pentru începători

Pe măsură ce programele tale cresc, codul devine greu de urmărit. Soluția? Funcțiile — bucăți de cod cu nume, pe care le scrii o dată și le folosești de câte ori ai nevoie. E ca o rețetă: o definești o dată, apoi spui doar "gătește felul X". Hai să le stăpânim.

O primă funcție

#include <iostream>

int patrat(int x) {
    return x * x;
}

int main() {
    std::cout << patrat(5) << std::endl;   // 25
    std::cout << patrat(9) << std::endl;   // 81
    return 0;
}

Hai să descompunem antetul int patrat(int x):

• int (primul) e tipul valorii returnate — funcția întoarce un întreg.
• patrat e numele funcției.
• (int x) e parametrul — datele de intrare.

return trimite rezultatul înapoi celui care a apelat funcția.

Funcții fără valoare returnată: void

Unele funcții doar fac ceva (afișează, modifică), fără să întoarcă un rezultat. Folosești void:

#include <iostream>

void salut(std::string nume) {
    std::cout << "Salut, " << nume << "!" << std::endl;
}

int main() {
    salut("Andrei");
    salut("Maria");
    return 0;
}

De ce sunt funcțiile atât de utile

Imaginează-ți că ai nevoie de cel mai mare divizor comun de mai multe ori. Scrii o funcție și o refolosești:

#include <iostream>

int cmmdc(int a, int b) {
    while (b != 0) {
        int rest = a % b;
        a = b;
        b = rest;
    }
    return a;
}

int main() {
    std::cout << cmmdc(48, 36) << std::endl;   // 12
    std::cout << cmmdc(100, 75) << std::endl;  // 25
    return 0;
}

Cele trei mari avantaje:

1. Refolosire — scrii logica o dată.
2. Claritate — numele funcției explică ce face codul.
3. Întreținere — corectezi un bug într-un singur loc.

Transmitere prin valoare vs. prin referință

În mod normal, parametrii se transmit prin valoare: funcția primește o copie. Modificările din interior nu afectează variabila originală:

void incearca(int x) {
    x = 100;   // modifica doar copia
}
// dupa apel, variabila originala ramane neschimbata

Dacă vrei ca funcția să modifice variabila reală, folosești o referință cu &:

#include <iostream>

void dubleaza(int &x) {
    x = x * 2;   // modifica originalul
}

int main() {
    int n = 7;
    dubleaza(n);
    std::cout << n << std::endl;   // 14
    return 0;
}

Referințele sunt utile și pentru performanță: pentru un std::vector mare, transmiterea prin referință evită copierea inutilă a tuturor elementelor.

Declarare vs. definire

Compilatorul citește de sus în jos. Dacă main apelează o funcție definită mai jos, trebuie să-i anunți prototipul la început:

#include <iostream>

int suma(int a, int b);   // declaratie (prototip)

int main() {
    std::cout << suma(3, 4) << std::endl;
    return 0;
}

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

Termen	Înseamnă
Declarație	spui că funcția există (antet + ;)
Definiție	scrii efectiv corpul funcției
Apel	folosești funcția: suma(3, 4)

De reținut

O funcție bună face un singur lucru, are un nume clar și e ușor de testat. Când simți că o bucată de cod se repetă, e semnalul perfect să o transformi într-o funcție.

---

La ByteSchool te învățăm să structurezi codul ca un profesionist, nu doar să-l faci să meargă. Cu mentori din Big Tech și exerciții pas cu pas, ajungi să scrii funcții curate pe care orice coleg le înțelege dintr-o privire. Te așteptăm să exersezi cu noi.