⚙️ Funcții și Subprograme

Structura unei funcții

// tip_returnat  nume_functie(parametri) { corp }

int suma(int a, int b) {   // parametri prin valoare
    return a + b;           // valoarea returnată
}

bool estePar(int n) {
    return n % 2 == 0;     // true dacă n este par
}

void afiseazaLinie() {     // void = nu returnează nimic
    cout << "----------------" << endl;
}

int main() {
    int rezultat = suma(3, 7);   // apel funcție → rezultat = 10
    cout << rezultat << endl;
    if (estePar(4)) cout << "4 este par" << endl;
    afiseazaLinie();              // apel funcție void
    return 0;
}

Când transmitem un parametru prin valoare, funcția primește o copie a argumentului. Modificările din funcție nu afectează variabila originală.

void dublu(int x) {
    x = x * 2;        // modificăm copia, nu originalul
    cout << x << endl;  // afișează 10
}

int main() {
    int a = 5;
    dublu(a);          // trimitem valoarea 5, nu variabila
    cout << a << endl; // afișează 5 — a nu s-a modificat!
}

Parametru cu valoare implicită (C++)

int putere(int baza, int exp = 2) {  // exp implicit = 2
    int rez = 1;
    for (int i = 0; i < exp; i++) rez *= baza;
    return rez;
}

cout << putere(3, 3);  // 27 — folosim exp=3
cout << putere(5);     // 25 — folosim exp implicit=2

Parametrii prin referință (marcați cu &) permit funcției să modifice direct variabila originală. Nu se creează copie.

void dublu(int &x) {  // & = referință la variabila originală
    x = x * 2;
}

int main() {
    int a = 5;
    dublu(a);           // a devine 10
    cout << a << endl;  // 10 — a s-a modificat!
}

Cazul clasic: funcție de schimbare (swap)

void schimba(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int x = 3, y = 7;
schimba(x, y);  // acum x=7, y=3

Citire în funcție — referință la n

void citesteVector(int v[], int &n) {  // n prin referință
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> v[i];
}

int v[100001], n;
citesteVector(v, n);  // n se actualizează în main

Funcții care returnează o valoare

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

bool ePrim(int n) {
    if (n < 2) return false;
    for (int i = 2; i * i <= n; i++)
        if (n % i == 0) return false;
    return true;             // returnează bool
}

double medie(int v[], int n) {
    int s = 0;
    for (int i = 1; i <= n; i++) s += v[i];
    return (double)s / n;     // returnează double
}

Funcții void (fără valoare returnată)

void afiseazaVector(int v[], int n) {
    for (int i = 1; i <= n; i++)
        cout << v[i] << " ";
    cout << endl;
}  // nu există return (sau return; fără valoare)

void sorteaza(int v[], int n) {
    for (int i = 1; i < n; i++)
        for (int j = 1; j <= n-i; j++)
            if (v[j] > v[j+1]) swap(v[j], v[j+1]);
}

int n;               // variabilă GLOBALĂ — vizibilă în tot programul
int v[100001];       // inițializat automat cu 0 (global)

void calcul() {
    int suma = 0;      // variabilă LOCALĂ — există doar în calcul()
    for (int i = 1; i <= n; i++)
        suma += v[i];   // accesează globalele n și v
    cout << suma;
}  // suma e distrusă la ieșirea din calcul()

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> v[i];
    calcul();
}

C++ oferă o serie de funcții gata scrise pe care le poți folosi incluzând header-ul corespunzător.

<algorithm> — cel mai util la BAC

#include <algorithm>

sort(v + 1, v + n + 1);              // sortare crescătoare O(n log n)
sort(v + 1, v + n + 1, greater<int>());  // sortare descrescătoare
int mx = *max_element(v+1, v+n+1);   // maximul din vector
int mn = *min_element(v+1, v+n+1);   // minimul din vector
reverse(v+1, v+n+1);                 // inversează vectorul
int m = max(a, b);  // maximul a doi scalari
int mn2 = min(a, b);

<cmath> — funcții matematice

#include <cmath>

sqrt(16.0)   // → 4.0  (rădăcina pătrată)
pow(2, 10)  // → 1024 (2 la puterea 10)
abs(-5)     // → 5    (valoare absolută)
floor(3.7) // → 3    (rotunjire în jos)
ceil(3.2)  // → 4    (rotunjire în sus)

<string> — metode pe string

#include <string>

string s = "Hello";
s.length()        // 5 — lungimea
s.substr(1, 3)    // "ell" — subsecvență de la 1, lungime 3
s.find("ll")      // 2 — poziția primei apariții
s + " World"      // "Hello World" — concatenare
s[0]              // 'H' — acces caracter la indice 0