Esercizi Smart Pointers C++

Ecco degli esercizi con soluzione per praticare l’utilizzo degli Smart Pointers in C++.

Esercizio 1: Utilizzo di std::unique_ptr

Creare un programma che utilizza `std::unique_ptr` per gestire la memoria di un oggetto.

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "Costruttore MyClass" << std::endl;
    }
    ~MyClass() {
        std::cout << "Distruttore MyClass" << std::endl;
    }
    void display() const {
        std::cout << "Metodo display di MyClass" << std::endl;
    }
};

int main() {
    std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();
    ptr->display();
    return 0;
}

Esercizio 2: Trasferimento di proprietà con std::unique_ptr

Creare un programma che trasferisce la proprietà di un oggetto gestito da `std::unique_ptr` a un altro `std::unique_ptr`.

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "Costruttore MyClass" << std::endl;
    }
    ~MyClass() {
        std::cout << "Distruttore MyClass" << std::endl;
    }
    void display() const {
        std::cout << "Metodo display di MyClass" << std::endl;
    }
};

int main() {
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
    ptr1->display();
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);
    if (!ptr1) {
        std::cout << "ptr1 è nullo" << std::endl;
    }
    ptr2->display();
    return 0;
}

Esercizio 3: Utilizzo di std::shared_ptr

Creare un programma che utilizza `std::shared_ptr` per gestire la memoria di un oggetto.

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "Costruttore MyClass" << std::endl;
    }
    ~MyClass() {
        std::cout << "Distruttore MyClass" << std::endl;
    }
    void display() const {
        std::cout << "Metodo display di MyClass" << std::endl;
    }
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = ptr1;
    ptr1->display();
    ptr2->display();
    std::cout << "Contatore di riferimenti: " << ptr1.use_count() << std::endl;
    return 0;
}

Esercizio 4: Creazione di un ciclo di riferimenti con std::shared_ptr

Creare un ciclo di riferimenti con `std::shared_ptr` e dimostrare il problema.

#include <iostream>
#include <memory>

class B;

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() {
        std::cout << "Distruttore A" << std::endl;
    }
};

class B {
public:
    std::shared_ptr<A> a_ptr;
    ~B() {
        std::cout << "Distruttore B" << std::endl;
    }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a;
    std::cout << "Creazione di un ciclo di riferimenti" << std::endl;
    return 0;
}

Esercizio 5: Risoluzione del ciclo di riferimenti con std::weak_ptr

Risolvere il ciclo di riferimenti utilizzando `std::weak_ptr`.

#include <iostream>
#include <memory>

class B;

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() {
        std::cout << "Distruttore A" << std::endl;
    }
};

class B {
public:
    std::weak_ptr<A> a_ptr;
    ~B() {
        std::cout << "Distruttore B" << std::endl;
    }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a;
    std::cout << "Ciclo di riferimenti risolto con std::weak_ptr" << std::endl;
    return 0;
}

Esercizio 6: Utilizzo di std::weak_ptr per controllare l’esistenza dell’oggetto

Creare un programma che utilizza `std::weak_ptr` per controllare se un oggetto esiste ancora.

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "Costruttore MyClass" << std::endl;
    }
    ~MyClass() {
        std::cout << "Distruttore MyClass" << std::endl;
    }
    void display() const {
        std::cout << "Metodo display di MyClass" << std::endl;
    }
};

int main() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
    std::weak_ptr<MyClass> weak_ptr = ptr;

    if (auto spt = weak_ptr.lock()) { // Controlla se l'oggetto esiste ancora
        spt->display();
    } else {
        std::cout << "L'oggetto non esiste più" << std::endl;
    }

    ptr.reset(); // Dealloca l'oggetto

    if (auto spt = weak_ptr.lock()) {
        spt->display();
    } else {
        std::cout << "L'oggetto non esiste più" << std::endl;
    }

    return 0;
}

Esercizio 7: Conversione di std::unique_ptr in std::shared_ptr

Creare un programma che converte un `std::unique_ptr` in un `std::shared_ptr`.

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "Costruttore MyClass" << std::endl;
    }
    ~MyClass() {
        std::cout << "Distruttore MyClass" << std::endl;
    }
    void display() const {
        std::cout << "Metodo display di MyClass" << std::endl;
    }
};

int main() {
    std::unique_ptr<MyClass> uniquePtr = std::make_unique<MyClass>();
    std::shared_ptr<MyClass> sharedPtr = std::move(uniquePtr);

    if (!uniquePtr) {
        std::cout << "uniquePtr è nullo" << std::endl;
    }

    sharedPtr->display();
    return 0;
}

Esercizio 8: Utilizzo di std::shared_ptr con array

Creare un programma che utilizza `std::shared_ptr` per gestire un array dinamico.

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int[]> arr(new int[5]);

    for (int i = 0; i < 5; ++i) {
        arr[i] = i;
    }

    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout <<

 std::endl;

    return 0;
}

Esercizio 9: Implementazione di una funzione di fabbrica con std::shared_ptr

Creare una funzione di fabbrica che restituisce un `std::shared_ptr` a un nuovo oggetto.

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "Costruttore MyClass" << std::endl;
    }
    ~MyClass() {
        std::cout << "Distruttore MyClass" << std::endl;
    }
    void display() const {
        std::cout << "Metodo display di MyClass" << std::endl;
    }
};

std::shared_ptr<MyClass> createMyClass() {
    return std::make_shared<MyClass>();
}

int main() {
    std::shared_ptr<MyClass> ptr = createMyClass();
    ptr->display();
    return 0;
}

Esercizio 10: Utilizzo di std::shared_ptr in una classe

Creare una classe che utilizza `std::shared_ptr` per gestire la memoria di un oggetto membro.

#include <iostream>
#include <memory>

class Member {
public:
    Member() {
        std::cout << "Costruttore Member" << std::endl;
    }
    ~Member() {
        std::cout << "Distruttore Member" << std::endl;
    }
    void display() const {
        std::cout << "Metodo display di Member" << std::endl;
    }
};

class MyClass {
private:
    std::shared_ptr<Member> member;
public:
    MyClass() : member(std::make_shared<Member>()) {}
    void display() const {
        member->display();
    }
};

int main() {
    MyClass obj;
    obj.display();
    return 0;
}