Esercizi Scope e Lifetime C++

Ecco degli esercizi con soluzione per praticare l’utilizzo di scope e lifetime delle variabili in C++.

Esercizio 1: Scope delle variabili locali

Creare una funzione che dichiara variabili locali e stampare i loro valori all'interno e all'esterno del loro scope.

#include <iostream>

void testScope() {
    int x = 10;
    {
        int y = 20;
        std::cout << "Dentro il blocco: x = " << x << ", y = " << y << std::endl;
    }
    // y non è accessibile qui
    std::cout << "Fuori dal blocco: x = " << x << std::endl;
}

int main() {
    testScope();
    return 0;
}

Esercizio 2: Lifetime delle variabili statiche

Creare una funzione che utilizza una variabile statica e osservare come il suo valore persiste tra chiamate successive alla funzione.

#include <iostream>

void incrementa() {
    static int counter = 0;
    counter++;
    std::cout << "Counter: " << counter << std::endl;
}

int main() {
    incrementa(); // Counter: 1
    incrementa(); // Counter: 2
    incrementa(); // Counter: 3
    return 0;
}

Esercizio 3: Variabili globali e scope

Dichiarare e utilizzare una variabile globale in diverse funzioni.

#include <iostream>

int globale = 0;

void incrementaGlobale() {
    globale++;
}

void stampaGlobale() {
    std::cout << "Globale: " << globale << std::endl;
}

int main() {
    incrementaGlobale();
    stampaGlobale(); // Globale: 1
    incrementaGlobale();
    stampaGlobale(); // Globale: 2
    return 0;
}

Esercizio 4: Scope dei parametri delle funzioni

Dimostrare che i parametri delle funzioni hanno lo scope limitato alla funzione stessa.

#include <iostream>

void funzione(int parametro) {
    std::cout << "Parametro: " << parametro << std::endl;
}

int main() {
    int valore = 42;
    funzione(valore);
    // parametro non è accessibile qui
    return 0;
}

Esercizio 5: Variabili automatiche e dinamiche

Confrontare il lifetime delle variabili automatiche e dinamiche.

#include <iostream>

void automaticVar() {
    int a = 10;
    std::cout << "Automatic Variable: " << a << std::endl;
}

void dynamicVar() {
    int* p = new int(20);
    std::cout << "Dynamic Variable: " << *p << std::endl;
    delete p;
}

int main() {
    automaticVar();
    // a non è accessibile qui
    dynamicVar();
    // p non è accessibile qui
    return 0;
}

Esercizio 6: Scope di variabili nelle classi

Dichiarare variabili membro e variabili locali in una classe e dimostrare il loro scope.

#include <iostream>

class MyClass {
private:
    int membro;
public:
    MyClass(int valore) : membro(valore) {}

    void funzione() {
        int locale = 20;
        std::cout << "Membro: " << membro << ", Locale: " << locale << std::endl;
    }
};

int main() {
    MyClass obj(10);
    obj.funzione();
    // membro e locale non sono accessibili qui
    return 0;
}