Esercizi Distruttori Classi C++

Ecco degli esercizi semplici con soluzione per praticare le basi dei distruttori delle classi in C++.

Esercizio 1: Distruttore di default

Creare una classe con un distruttore di default e stampare un messaggio quando viene chiamato.

#include <iostream>

class Esempio {
public:
    Esempio() {
        std::cout << "Costruttore chiamato" << std::endl;
    }
    ~Esempio() {
        std::cout << "Distruttore chiamato" << std::endl;
    }
};

int main() {
    Esempio e;
    return 0;
}

Esercizio 2: Distruttore per liberare memoria dinamica

Creare una classe con un distruttore che libera memoria allocata dinamicamente.

#include <iostream>

class Esempio {
private:
    int* data;
public:
    Esempio(int size) {
        data = new int[size];
        std::cout << "Memoria allocata" << std::endl;
    }
    ~Esempio() {
        delete[] data;
        std::cout << "Memoria deallocata" << std::endl;
    }
};

int main() {
    Esempio e(10);
    return 0;
}

Esercizio 3: Distruttore per chiudere un file

Creare una classe con un distruttore che chiude un file aperto nel costruttore.

#include <iostream>
#include <fstream>

class FileHandler {
private:
    std::ofstream file;
public:
    FileHandler(const std::string& filename) {
        file.open(filename);
        if (file.is_open()) {
            std::cout << "File aperto" << std::endl;
        }
    }
    ~FileHandler() {
        if (file.is_open()) {
            file.close();
            std::cout << "File chiuso" << std::endl;
        }
    }
};

int main() {
    FileHandler fh("esempio.txt");
    return 0;
}

Esercizio 4: Distruttore per oggetti smart pointer

Creare una classe con un distruttore che dealloca oggetti gestiti da smart pointer.

#include <iostream>
#include <memory>

class Esempio {
private:
    std::unique_ptr<int> ptr;
public:
    Esempio(int val) : ptr(std::make_unique<int>(val)) {
        std::cout << "Costruttore chiamato" << std::endl;
    }
    ~Esempio() {
        std::cout << "Distruttore chiamato" << std::endl;
    }
};

int main() {
    Esempio e(42);
    return 0;
}

Esercizio 5: Distruttore per una classe base

Creare una classe base con un distruttore virtuale e una classe derivata.

#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Costruttore Base chiamato" << std::endl;
    }
    virtual ~Base() {
        std::cout << "Distruttore Base chiamato" << std::endl;
    }
};

class Derivata : public Base {
public:
    Derivata() {
        std::cout << "Costruttore Derivata chiamato" << std::endl;
    }
    ~Derivata() {
        std::cout << "Distruttore Derivata chiamato" << std::endl;
    }
};

int main() {
    Base* ptr = new Derivata();
    delete ptr;
    return 0;
}

Esercizio 6: Distruttore per gestire risorse multiple

Creare una classe con un distruttore che gestisce la deallocazione di risorse multiple.

#include <iostream>

class GestoreRisorse {
private:
    int* memoria1;
    int* memoria2;
public:
    GestoreRisorse() {
        memoria1 = new int[10];
        memoria2 = new int[20];
        std::cout << "Risorse allocate" << std::endl;
    }
    ~GestoreRisorse() {
        delete[] memoria1;
        delete[] memoria2;
        std::cout << "Risorse deallocate" << std::endl;
    }
};

int main() {
    GestoreRisorse gr;
    return 0;
}

Esercizio 7: Distruttore per una classe contenente oggetti di altre classi

Creare una classe con un distruttore che gestisce la deallocazione di oggetti di altre classi.

#include <iostream>

class AltraClasse {
public:
    AltraClasse() {
        std::cout << "Costruttore AltraClasse chiamato" << std::endl;
    }
    ~AltraClasse() {
        std::cout << "Distruttore AltraClasse chiamato" << std::endl;
    }
};

class Esempio {
private:
    AltraClasse ac;
public:
    Esempio() {
        std::cout << "Costruttore Esempio chiamato" << std::endl;
    }
    ~Esempio() {
        std::cout << "Distruttore Esempio chiamato" << std::endl;
    }
};

int main() {
    Esempio e;
    return 0;
}

Esercizio 8: Distruttore per oggetti dinamici

Creare una classe con un distruttore che dealloca oggetti creati dinamicamente nel costruttore.

#include <iostream>

class Esempio {
private:
    AltraClasse* ac;
public:
    Esempio() {
        ac = new AltraClasse();
        std::cout << "Costruttore Esempio chiamato" << std::endl;
    }
    ~Esempio() {
        delete ac;
        std::cout << "Distruttore Esempio chiamato" << std::endl;
    }
};

int main() {
    Esempio e;
    return 0;
}

Esercizio 9: Distruttore per una classe con array di oggetti

Creare una classe con un distruttore che dealloca un array di oggetti.

#include <iostream>

class AltraClasse {
public:
    AltraClasse() {
        std::cout << "Costruttore AltraClasse chiamato" << std::endl;
    }
    ~AltraClasse() {
        std::cout << "Distruttore AltraClasse chiamato" << std::endl;
    }
};

class Esempio {
private:
    AltraClasse* arr;
    int size;
public:
    Esempio(int s) : size(s) {
        arr = new AltraClasse[size];
        std::cout << "Array di AltraClasse allocato" << std::endl;
    }
    ~Esempio() {
        delete[] arr;
        std::cout << "Array di AltraClasse deallocato" << std::endl;
    }
};

int main() {
    Esempio e(5);
    return 0;
}

Esercizio 10: Distruttore per oggetti con file aperti

Creare una classe con un distruttore che chiude un file aperto.

#include <iostream>
#include <fstream>

class GestoreFile {
private:
    std::ofstream file;
public:
    GestoreFile(const std::string& filename

) {
        file.open(filename);
        if (file.is_open()) {
            std::cout << "File aperto" << std::endl;
        }
    }
    ~GestoreFile() {
        if (file.is_open()) {
            file.close();
            std::cout << "File chiuso" << std::endl;
        }
    }
};

int main() {
    GestoreFile gf("esempio.txt");
    return 0;
}