Funzioni

#include <stdio.h>

// PROTOTIPO: dichiara che la funzione esiste (prima del main)
// tipo_ritorno nome(tipo param1, tipo param2);
double media(double a, double b);
int massimo(int x, int y);
void saluta(char nome[]);  // void = non ritorna nulla

int main() {
    printf("Media: %.2f\n", media(10.5, 7.3));
    printf("Max:   %d\n",   massimo(42, 17));
    saluta("Giulia");
    return 0;
}

// DEFINIZIONE: il corpo della funzione
double media(double a, double b) {
    return (a + b) / 2.0;
}

int massimo(int x, int y) {
    return (x > y) ? x : y;
}

void saluta(char nome[]) {
    printf("Ciao, %s!\n", nome);
    // Nessun return (o return; senza valore)
}

#include <stdio.h>

// Passaggio per VALORE: la modifica non si propaga
void tenta_incremento(int n) {
    n += 10;  // Modifica la copia locale, non l'originale
    printf("Dentro la funzione: n = %d\n", n);
}

// Passaggio per PUNTATORE: la modifica si propaga
void incrementa(int *n) {
    *n += 10;  // Dereferenzia il puntatore e modifica l'originale
}

// Scambia due valori tramite puntatori
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5;
    tenta_incremento(x);
    printf("Dopo tenta_incremento: x = %d\n\n", x);  // Ancora 5!

    incrementa(&x);  // Passa l'indirizzo di x
    printf("Dopo incrementa: x = %d\n\n", x);  // 15

    int a = 10, b = 20;
    printf("Prima swap: a=%d, b=%d\n", a, b);
    swap(&a, &b);
    printf("Dopo swap:  a=%d, b=%d\n", a, b);

    return 0;
}

#include <stdio.h>

int globale = 100;  // Visibile in tutto il file

void dimostra_static() {
    static int contatore = 0;  // Inizializzata UNA SOLA VOLTA, persiste
    contatore++;
    printf("Chiamata n. %d\n", contatore);
}

void dimostra_scope() {
    int locale = 10;       // Visibile solo in questa funzione
    {
        int interno = 20;  // Visibile solo in questo blocco
        printf("interno = %d\n", interno);
    }
    // printf("%d", interno);  // ERRORE! interno non esiste qui
    printf("locale = %d, globale = %d\n", locale, globale);
}

int main() {
    dimostra_scope();

    dimostra_static();  // Chiamata 1
    dimostra_static();  // Chiamata 2
    dimostra_static();  // Chiamata 3

    return 0;
}

#include <stdio.h>

// Fattoriale: n! = n * (n-1)!   Base: 0! = 1
long long fattoriale(int n) {
    if (n <= 0) return 1;        // Caso base
    return n * fattoriale(n - 1); // Chiamata ricorsiva
}

// Fibonacci: f(n) = f(n-1) + f(n-2)   Base: f(0)=0, f(1)=1
long long fibonacci(int n) {
    if (n <= 0) return 0;
    if (n == 1) return 1;
    return fibonacci(n-1) + fibonacci(n-2);
}

// MCD (Massimo Comun Divisore) — algoritmo di Euclide
int mcd(int a, int b) {
    if (b == 0) return a;
    return mcd(b, a % b);
}

// Potenza: base^esp
double potenza(double base, int esp) {
    if (esp == 0) return 1.0;
    if (esp < 0)  return 1.0 / potenza(base, -esp);
    return base * potenza(base, esp - 1);
}

int main() {
    for (int i = 0; i <= 10; i++)
        printf("%d! = %lld\n", i, fattoriale(i));

    printf("\nFibonacci (0-10): ");
    for (int i = 0; i <= 10; i++)
        printf("%lld ", fibonacci(i));
    printf("\n");

    printf("\nMCD(48, 18) = %d\n", mcd(48, 18));
    printf("2^10 = %.0f\n", potenza(2.0, 10));

    return 0;
}

#include <stdio.h>

int somma(int a, int b)  { return a + b; }
int diff(int a, int b)   { return a - b; }
int prodotto(int a, int b){ return a * b; }

// Funzione che accetta un puntatore a funzione come parametro
int applica(int a, int b, int (*operazione)(int, int)) {
    return operazione(a, b);
}

int main() {
    // Sintassi: tipo (*nome_puntatore)(tipi_parametri)
    int (*op)(int, int);

    op = somma;
    printf("Somma:    %d\n", op(10, 5));

    op = diff;
    printf("Diff:     %d\n", op(10, 5));

    op = prodotto;
    printf("Prodotto: %d\n", op(10, 5));

    // Array di puntatori a funzione
    int (*operazioni[3])(int, int) = {somma, diff, prodotto};
    char *nomi[] = {"somma", "diff", "prodotto"};

    for (int i = 0; i < 3; i++) {
        printf("%s(7, 3) = %d\n", nomi[i], operazioni[i](7, 3));
    }

    // Passaggio come argomento
    printf("\napplica(10,5,somma)    = %d\n", applica(10, 5, somma));
    printf("applica(10,5,prodotto) = %d\n", applica(10, 5, prodotto));

    return 0;
}