Esercizi Smart Pointers C++
Codegrind Team•Jul 12 2024
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;
}