Funzioni e Passaggio Parametri

// DEFINIZIONE: tipo_ritorno nome(parametri) { corpo }
int somma(int a, int b) {      // riceve due int, restituisce un int
    return a + b;              // valore restituito al chiamante
}

int main() {
    int ris = somma(3, 5);    // CHIAMATA: passa 3 e 5 come argomenti
    cout << ris;               // stampa 8
    return 0;
}

// void: non restituisce nulla
void saluta(string nome) {
    cout << "Ciao, " << nome << "!" << endl;
    // return; si usa solo per uscire anticipatamente (es. controllo errori)
    // in assenza di condizioni particolari, non va scritto
}

// con valore di ritorno: calcola e restituisce un risultato al chiamante
float media(float a, float b) {
    return (a + b) / 2.0f;
}

int main() {
    saluta("Mario");
    float m = media(7.5f, 8.0f);
    cout << "Media: " << m << endl;  // 7.75
    return 0;
}

void prova(int x) {       // x è una COPIA del parametro
    x = x * 2;            // modifica solo la copia locale
    cout << "dentro: " << x << endl;
}

int main() {
    int a = 5;
    prova(a);
    cout << "fuori: " << a << endl;  // stampa 5 — a NON è cambiato
    return 0;
}

void raddoppia(int& x) {  // & = riferimento: x è un alias di chi viene passato
    x = x * 2;            // modifica DIRETTAMENTE la variabile del chiamante
}

void scambia(int& a, int& b) {
    int tmp = a; a = b; b = tmp;
}

int main() {
    int n = 5;
    raddoppia(n);
    cout << n << endl;          // 10 — n è cambiato

    int x = 3, y = 7;
    scambia(x, y);
    cout << x << " " << y;     // 7 3
    return 0;
}

// senza const: efficiente ma la funzione potrebbe modificare s
void stampa(string& s) { cout << s; }

// con const: zero copie + garanzia che s non venga modificata
void stampa(const string& s) {
    cout << s << endl;
    // s = "altro";  // ❌ errore di compilazione: s è const
}

int main() {
    string nome = "Mario Rossi";
    stampa(nome);   // zero copie, nessuna modifica possibile
    return 0;
}

void raddoppia(int* p) {
    if (p == nullptr) return;  // controlla sempre prima di dereferenziare
    *p = *p * 2;              // * = vai all'indirizzo e modifica il valore
}

int main() {
    int n = 5;
    raddoppia(&n);             // & = passa l'indirizzo di n
    cout << n << endl;         // 10
    return 0;
}

// queste tre firme sono equivalenti per il compilatore:
void stampa(int arr[], int n)      // forma più leggibile — preferita
void stampa(int* arr, int n)      // equivalente: arr diventa puntatore
void stampa(int arr[10], int n)   // la dimensione [10] è ignorata

// funzione che LEGGE l'array (const = nessuna modifica accidentale)
void stampa(const int arr[], int n) {
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    cout << endl;
}

// funzione che MODIFICA l'array
void raddoppia(int arr[], int n) {
    for (int i = 0; i < n; i++)
        arr[i] *= 2;   // modifica l'array originale
}

int main() {
    int v[5] = {1, 2, 3, 4, 5};
    stampa(v, 5);      // 1 2 3 4 5
    raddoppia(v, 5);
    stampa(v, 5);      // 2 4 6 8 10
    return 0;
}

// prima dimensione [] omessa: ok
// seconda dimensione [3]: OBBLIGATORIA
void stampa(int mat[][3], int righe) {
    for (int i = 0; i < righe; i++) {
        for (int j = 0; j < 3; j++)
            cout << mat[i][j] << "\t";
        cout << endl;
    }
}

void azzera(int mat[][3], int righe) {
    for (int i = 0; i < righe; i++)
        for (int j = 0; j < 3; j++)
            mat[i][j] = 0;   // modifica la matrice originale
}

int main() {
    int m[2][3] = {{1,2,3}, {4,5,6}};
    stampa(m, 2);   // 1 2 3 / 4 5 6
    azzera(m, 2);
    stampa(m, 2);   // 0 0 0 / 0 0 0
    return 0;
}

// ── PROTOTIPI ─────────────────────────────────────────────
// Il compilatore conosce le funzioni ancora prima di vederle
int  somma(int a, int b);       // tipo ritorno + nome + tipi parametri
void saluta(string nome);        // i nomi parametro sono opzionali

// ── MAIN ──────────────────────────────────────────────────
int main() {
    int ris = somma(4, 7);       // OK: somma è già dichiarata
    saluta("Mario");              // OK: saluta è già dichiarata
    cout << "Somma: " << ris << endl;
    return 0;
}

// ── DEFINIZIONI ───────────────────────────────────────────
// Devono corrispondere esattamente al prototipo
int somma(int a, int b) {
    return a + b;
}

void saluta(string nome) {
    cout << "Ciao, " << nome << "!" << endl;
}